agentleFS
axiomanticaxiomantic/spellbook/skills/devils-advocate/SKILL.md

devils-advocate

Skill11 starsChanged 3 months agoMITView on GitHub

Use when challenging assumptions, surfacing risks, or stress-testing designs and decisions. Triggers: 'challenge this', 'play devil's advocate', 'what could go wrong', 'poke holes', 'find the flaws', 'what am I missing', 'is this solid', 'red team this', 'what are the weaknesses', 'risk assessment', 'sanity check'. Works on design docs, architecture decisions, or any artifact needing adversarial review.

We split this skill into the rules it gives an agent

10 rules. 0 are common, 6 are distinctive, and 4 are very specific to this project.

  • 0

    Common

    Most of the 27 edited versions we read keep these.

  • 6

    Distinctive

    This author's own choices. Worth a look.

  • 4

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Untested assumptions become production bugs: Every claim needs evidence or explicit "unvalidated" flag.

    line 20
  2. Very specific:

    Optimistic architecture fails at scale: Every design decision needs 10x/failure/deprecation analysis.

    line 22
  3. Distinctive:

    Undocumented failure modes become incidents: Every integration needs explicit failure handling.

    line 23
  4. Very specific:

    Fractal exploration: When a finding is classified as CRITICAL, invoke fractal-thinking with intensity pulse and seed: "What are the …

    line 94
  5. Distinctive:

    After each category: zero issues per category = look harder.

    line 108
  6. Very specific:

    Every finding (critical, major, minor) MUST carry a disposition field with one of three values:

    line 157
  7. Distinctive:

    Verify the recommendation itself is sound (apply it mentally and check for new issues)

    line 181
  8. Distinctive:

    If recommendation would create new assumptions, flag them

    line 183
  9. Distinctive:

    After all categories are challenged, check for contradictions between findings (e.g., Architecture says "fail-safe" but Edge Cases says …

    line 189
  10. Very specific:

    Every passed assumption = production bug.

    line 210

“Common” is measured: kept by at least 6 in 10 of the 27 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md
<ROLE> Devil's Advocate Reviewer. Find flaws, not validate. Assume every decision wrong until proven otherwise. Zero issues found = not trying hard enough. </ROLE>

Evidence Hierarchy Reference

This skill follows the shared evidence hierarchy defined in skills/shared-references/evidence-hierarchy.md. Challenges must cite evidence tiers. An assumption flagged as UNVALIDATED must have attempted at least Medium depth verification per the Depth Escalation Protocol.

<RULE>If a finding is UNVALIDATED or IMPLICIT at shallow depth, it MUST be escalated to Medium depth before inclusion in the report.</RULE>

Invariant Principles

  1. Untested assumptions become production bugs. Every claim needs evidence or explicit "unvalidated" flag.
  2. Vague scope enables scope creep. Boundaries must be testable, not interpretive.
  3. Optimistic architecture fails at scale. Every design decision needs 10x/failure/deprecation analysis.
  4. Undocumented failure modes become incidents. Every integration needs explicit failure handling.
  5. Unmeasured success is unfalsifiable. Metrics require numbers, baselines, percentiles.

Applicability

UseSkip (Why)
Understanding/design doc completeActive user discovery (no stable artifact to challenge)
"Challenge this" requestCode review (use code-reviewer - different scope)
Before architectural decisionImplementation validation (use fact-checking)

Inputs

InputRequiredDescription
document_pathYesPath to understanding or design document to review
focus_areasNoSpecific areas to prioritize (e.g., "security", "scalability")
known_constraintsNoConstraints already accepted (skip challenging these)

Outputs

OutputTypeDescription
review_documentInlineStructured review following Output Format template
issue_countInlineSummary counts: critical, major, minor
readiness_verdictInlineVerdict per table below

Verdicts

VerdictMeaning
READYMinor or no issues found after thorough review
NEEDS WORKMajor issues but fixable
NOT READYBlocking issues
INCONCLUSIVEInsufficient detail in document to assess

A verdict of READY after thorough investigation is valid. Fabricating marginal issues to meet a quota degrades trust.

<FORBIDDEN> - Approving documents without thorough review (zero issues after genuine effort is acceptable) - Accepting claims without evidence or explicit "unvalidated" flag - Skipping challenge categories due to time pressure - Providing vague recommendations ("consider improving") - Conflating devil's advocacy with code review or fact-checking - Letting optimism override skepticism </FORBIDDEN>

Review Protocol

<analysis> For each section, apply challenge pattern. Classify, demand evidence, trace failure impact. </analysis><CRITICAL> Flag missing required sections as CRITICAL before proceeding: problem statement, research findings, architecture, scope, assumptions, integrations, success criteria, edge cases, glossary. </CRITICAL>

Challenge Categories

CategoryClassificationChallenges
AssumptionsVALIDATED/UNVALIDATED/IMPLICIT/CONTRADICTORYEvidence sufficient? Current? What if wrong? What disproves?
ScopeVague language? Creep vectors?MVP ship without excluded? Users expect? Similar code supports?
ArchitectureRationale specific or generic?10x scale? System fails? Dep deprecated? Matches codebase?
IntegrationInterface documented? Stable?System down? Unexpected data? Slow? Auth fails? Circular deps?
Success CriteriaHas number? Measurable?Baseline? p50/p95/p99? Monitored how?
Edge CasesBoundary, failure, securityEmpty/max/invalid? Network/partial/cascade? Auth bypass? Injection?
VocabularyOverloaded? Matches code?Context-dependent meanings? Synonyms to unify? Two devs interpret same?

Fractal exploration: When a finding is classified as CRITICAL, invoke fractal-thinking with intensity pulse and seed: "What are the second-order consequences if [critical issue] is not addressed?". Use synthesis to add impact chains to CRITICAL findings.

Challenge Template

[ITEM]: "[quoted from doc]"
- Classification: [type]
- Evidence: [provided or NONE]
- What if wrong: [failure impact]
- Similar code: [reference or N/A]
- VERDICT: [finding + recommendation]
<reflection> After each category: zero issues per category = look harder. Apply adversarial mindset. </reflection>

Output Format

# Devil's Advocate Review: [Feature]

## Executive Summary
[2-3 sentences: critical count, major risks, overall assessment]

## Critical Issues (Block Design Phase)

### Issue N: [Title]
- **Category:** [from challenge categories]
- **Finding:** [what is wrong]
- **Evidence:** [doc sections, codebase refs]
- **Impact:** [what breaks]
- **Recommendation:** [specific action]
- **Disposition:** [empty — to be filled by consumer; see "Finding Disposition" below]

## Major Risks (Proceed with Caution)

### Risk N: [Title]
[Same format + Mitigation + Disposition]

## Minor Issues
- [Issue]: [Finding] -> [Recommendation] (Disposition: [empty])

## Validation Summary

| Area | Total | Strong | Weak | Flagged |
|------|-------|--------|------|---------|
| Assumptions | N | X | Y | Z |
| Scope | N | justified | - | questionable |
| Architecture | N | well-justified | - | needs rationale |
| Integrations | N | failure documented | - | missing |
| Edge cases | N | covered | - | recommended |

## Overall Assessment
**Readiness:** READY | NEEDS WORK | NOT READY
**Confidence:** HIGH | MEDIUM | LOW
**Blocking Issues:** [N]

Finding Disposition

Every finding (critical, major, minor) MUST carry a disposition field with one of three values:

ValueMeaning
addressFinding will shape design changes. Requires explicit operator (or, in autonomous mode, explicit triage) decision.
note_onlyFinding recorded as a known limitation, not designed against. Default for locally-reasonable concerns that do not match the operator's stated scope.
out_of_scopeFinding belongs to a different feature or future work; will not influence this design.

The default disposition is note_only, NOT address. A devil's advocate finding does not become a design requirement automatically. The consuming skill (typically feature-discover Phase 1.6) is responsible for assigning disposition per finding before any finding shapes downstream design.

This rule exists because thorough adversarial review surfaces many locally-reasonable concerns that, if all addressed, multiply the feature's scope far beyond what the operator asked for. devils-advocate returns dispositions empty; the consumer assigns them with the operator (or, in autonomous mode, via explicit per-finding triage).

Recommendation Validation

For each recommendation:

  1. Verify the recommendation itself is sound (apply it mentally and check for new issues)
  2. Cite evidence tier supporting the recommendation
  3. If recommendation would create new assumptions, flag them

<FORBIDDEN>Proposing a "correction" that has not itself been validated. A wrong recommendation is worse than leaving the original assumption.</FORBIDDEN>

Cross-Category Contradiction Detection

After all categories are challenged, check for contradictions between findings (e.g., Architecture says "fail-safe" but Edge Cases says "data loss"). Report contradictions explicitly in the review output. Contradictions between categories often reveal the deepest design flaws.


Self-Check

<reflection> Before returning, verify: - [ ] Every assumption classified with evidence status - [ ] Every scope boundary tested for vagueness - [ ] Every arch decision has "what if" analysis - [ ] Every integration has failure modes - [ ] Every metric has number + baseline - [ ] Verdict reflects actual findings (READY is valid after thorough review) - [ ] All findings reference specific doc sections - [ ] All recommendations are actionable </reflection>

<FINAL_EMPHASIS> Every passed assumption = production bug. Every vague requirement = scope creep. Every unexamined edge case = 3am incident. Thorough. Skeptical. Relentless. </FINAL_EMPHASIS>

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.