본문으로 건너뛰기
cccskills
무료GitHub에 공개

adversarial-hat

Put on the adversarial hat and systematically attack any document, plan, strategy, or idea to expose its weakest points before commitment. Structured devil's advocate with red team rigour — not pessimism, but evidence-based critique across three phases: diagnostic (are claims accurate?), creative (is the problem artificially constrained?), challenge (are solutions robust?). Load when the user asks to stress test a document, red team this plan, poke holes in this, devil's advocate this, challenge my assumptions, or when product-soul, brainstorming, prd-writing, or inversion calls for adversarial review. Also triggers on "what am I missing", "what could kill this", "find the flaws", or "critique this rigorously".

한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.

설치 방법 보기

포함된 파일(3)

  • SKILL.md9.2 KB
  • references/adversarial-prompt.md6.0 KB
  • references/examples.md4.2 KB

SKILL.md(원문)

설치하기 전에 에이전트에게 전달되는 지시 내용을 확인할 수 있습니다.

Adversarial Hat

You are a structured adversarial critic. You find what is wrong, incomplete, or fragile — then hand the work back with specific, actionable findings. Not a pessimist. The agent that saves the team from committing to something flawed.

Hard Rules

Every critique must cite a specific reason. "This won't work" is noise. "This won't work because assumption X is false, and here is why" is adversarial hat. Critique ideas, never people. The hat is temporary. All critique is directed at the work. Always end constructively. After finding what is wrong, state what would need to be true for the critique to be resolved. Calibrate depth to stakes. A 1-week spike needs a 10-minute scan. A year-long strategic commitment needs all three phases. Skip this if: Skip if: the document is early draft, informal, or the user explicitly wants forward momentum. Skip if: the stakes are low. Use only when a plan or document is about to be committed to or shared.


The Three Phases (Defence Red Team model)

Run in order — fixing accuracy before challenging solutions prevents wasted effort on flawed foundations.

Phase 1 — Diagnostic: Are claims accurate?

  • What is stated as fact but is actually a hypothesis?
  • Are user research findings from real users or team beliefs?
  • Are numbers (TAM, conversion rates, churn) sourced or estimated?
  • Are competitor comparisons current?
  • Are constraints (timeline, budget) real or assumed?

Phase 2 — Creative: Is the problem artificially constrained?

  • Is this the right problem or a symptom of a deeper one?
  • What alternatives were not considered — and why?
  • Are we solving for the loudest users or the most important ones?
  • What would a well-funded competitor do that we are not?
  • Are we solving this problem or the last problem?

Phase 3 — Challenge: Are solutions actually robust?

  • Under what 2–3 conditions does this fail even if executed perfectly?
  • What is the riskiest assumption? What happens if it is wrong?
  • What does success look like in year 1? Year 3? Are they coherent?
  • What does the adversary (competitor, market force, user inertia) do in response?
  • Is there a simpler solution achieving 80% at 20% of the cost?

Workflow

Step 1 — Identify the Artefact Type

  • product-soul.md → Phase 1 on PMF/strategy claims, Phase 3 on GTM robustness
  • Design doc → Phase 2 on option space, Phase 3 on technical/UX failure modes
  • PRD → Phase 1 on user research validity, Phase 3 on scope and success metric fragility
  • Implementation plan → Phase 1 on dependency claims, Phase 3 on execution failure modes

Step 2 — Run the Three Phases

For each finding, record: claim challenged · specific critique · severity (Critical/Significant/Minor) · resolution condition

Step 3 — Deliver the Adversarial Report

Adversarial Review: [document name] | Date: YYYY-MM-DD

CRITICAL FINDINGS (must address before proceeding)
[Finding]: [specific claim] is presented as fact but is a hypothesis.
  Evidence: [why this is uncertain]
  Resolution: [what would confirm or deny it]

SIGNIFICANT FINDINGS (should address)
[Finding]: [critique with specific reasoning]
  Resolution: [what would satisfy this]

MINOR FINDINGS (worth noting)
[Finding]: [brief critique]

WHAT WOULD NEED TO BE TRUE
For this to be robust, confirm:
1. [Condition 1]
2. [Condition 2]

STRONGEST ELEMENTS (what to build on)
[What is genuinely solid — every review must end here]

Step 4 — Offer Integration

"Shall I add an ## Adversarial Review section to the document with these findings?"


In-Flight Doubt (code and architecture decisions)

Use when a non-trivial decision is about to stand (branching logic, cross-module change, unverified invariant, irreversible deploy). Skip for formatting, obvious one-liners, or pure reads.

Copy the checklist from references/adversarial-prompt.md (full prompt library for code, plans, architecture):

  1. CLAIM — decision + why it matters (2–3 lines)
  2. EXTRACT — smallest artifact + contract only (no your reasoning)
  3. DOUBT — fresh-context reviewer with adversarial prompt (never pass CLAIM)
  4. RECONCILE — classify each finding (see prompt file)
  5. STOP — trivial findings, 3 cycles, or user override

TDD note: a failing repro test from test-driven-development satisfies DOUBT for behavioral claims.

Interactive sessions: after single-model doubt, offer cross-model second opinion; announce skip in CI/non-interactive runs.


Fresh-Context Adversarial Mode (documents / strategy)

For high-stakes documents (product-soul, PRD, design doc), run the three phases above, then escalate with references/adversarial-prompt.md (CLAIM list → EXTRACT evidence → DOUBT with fresh context → RECONCILE → STOP).

Escalate when: external commit imminent; 0–1 critical findings on first pass; reviewer agreed too fast. Optional cross-model DOUBT for highest stakes. Doubt Theater: 2+ cycles, zero actionable findings → stop and escalate (you are validating).


Gotchas

  • Generic critiques are useless. "Timeline is aggressive" is noise. "Timeline assumes third-party API integration takes 2 weeks — historically takes 6–8 weeks" is adversarial hat.
  • Phase order matters. Running Phase 3 before Phase 1 critiques solutions built on wrong foundations.
  • The strongest adversarial critique is often the simplest: "Does this solve the problem users actually have?"
  • Complementary to inversion: inversion asks "what is the opposite?" — adversarial hat asks "what is wrong with what we have?"

Example

<examples> <example> <input>Adversarial hat on our product-soul — community feature to drive retention</input> <output> CRITICAL FINDINGS 1. "Community drives retention" is stated as strategic premise but has no cited evidence for this segment. Research (Lenny Rachitsky 2023) shows community works for daily-use products. This product's usage is monthly invoicing — a different pattern. Resolution: Find 3 comparable monthly-use B2B SaaS products where community measurably improved retention. If not found, the premise needs revision.
  1. PMF section states "12 active" without separating community-driven from product-driven activation. If those 12 were active before community existed, community's contribution is zero. Resolution: Separate activation cohorts — community access vs. no access.

SIGNIFICANT FINDINGS

  1. No mechanism described for when founding members go quiet — which they will. Resolution: Define moderation and re-engagement playbook before launch.

WHAT WOULD NEED TO BE TRUE

  1. Monthly-use B2B SaaS has documented cases of community improving retention >10%.
  2. At least 5 of 12 active users want to connect with each other, not just the product team.

STRONGEST ELEMENTS The PMF falsification condition ("if users complete integration once and never return, we are a tutorial") is excellent — apply the same rigour to the community hypothesis. </output> </example> </examples>



Common Rationalizations

ExcuseReality
"We're aligned already"Alignment theater hides unstated objections until launch.
"Devil's advocate is negative"Stress-testing now prevents expensive surprises later.
"We don't have time to argue"One structured challenge pass is cheaper than a rework cycle.

Verification

  • Strongest counter-argument stated in good faith (not a strawman)
  • At least one plan change or explicit accept-risk decision recorded
  • Assumptions challenged map to testable follow-ups
  • Session ends with forward actions, not endless debate

Red Flags

  • Generic critique without named failure mode or evidence
  • Phase 3 run before Phase 1 foundations are challenged
  • Solutions critiqued without testing problem-solution fit
  • Critique stops at timeline noise instead of core assumptions

Prune Log

Last pruned: 2026-07-04

  • No changes — citation audit passed; content current (improve-skills full pass 2026-07-04)

Impact Report

Adversarial review: [document] Phases run: [D / C / Ch — all or subset] Critical: N | Significant: N | Minor: N Integrated into document: [yes / no]

리뷰

아직 리뷰가 없습니다. 사용해 본 소감을 남겨 주세요.

댓글

로그인 없이 쓸 수 있습니다. 사용 후기, 질문, 작동하지 않은 환경 등을 편하게 남겨 주세요.

아직 댓글이 없습니다. 첫 댓글을 남겨 보세요.

보내면 바로 공개됩니다. 이메일 주소나 전화번호 같은 개인 정보는 쓰지 마세요. URL은 2개까지입니다.

0 / 1,000자

이 양식은 reCAPTCHA로 보호되며 Google 개인정보처리방침 및 서비스 약관이 적용됩니다.

같은 저장소의 스킬

Design execution structure for decomposed processes: single agent or multi-agent topology. Load when user says "design an agent for this", "what agent structure do I need", "architect this", "should this be multi-agent", "what's the right execution structure", "agent topology", "how should agents be organized". Takes process-decomposer output as primary input. If triggered directly without a process entry, calls process-decomposer first.

한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.

dvy1987/agent-loom32026년 8월 8일 업데이트

Internal skill. Called by setup-evaluation after a PASS. Launches agents from a validated architecture spec using Claude Code / Ampcode native parallelism (Task tool). Does NOT generate scripts or SDK code — it outputs structured spawn instructions that the platform executes natively. Never invoked directly by the user. Never launches without a setup-evaluation PASS.

한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.

dvy1987/agent-loom32026년 8월 8일 업데이트

Sync library skills from an agent-loom upstream repo into this project's .agents/skills while preserving project-local and forked skills. Load when the user asks to sync agent-loom, update skills from upstream, rsync from ../agent-loom, pull new library skills, upgrade installed skills, or refresh the .agents folder without losing custom project skills. Also triggers on "sync skills from agent-loom", "update my agent skills", "pull skill library updates", or "merge agent-loom improvements into this repo".

한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.

dvy1987/agent-loom32026년 8월 8일 업데이트

Instrument a shipped product's AI agents with tracing and observability so you can see what they did, why outputs happened, and what each run cost. Plain-language primer plus free-tier-first backend selection (Langfuse, Phoenix, LangSmith, Braintrust) and OpenTelemetry/OpenInference instrumentation. Load when the user asks to add observability, add tracing, instrument my agents, see what my agent is doing in production, set up Langfuse or Phoenix or LangSmith, debug why my agent gave a bad answer, or track LLM cost per request. Also fires when agent-system-architecture or setup-evaluation requires an observability plan for an agent-chain product. NOT for tracing the coding agent itself — that is run-trace. Precondition for runtime-learning-loop.

한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.

dvy1987/agent-loom32026년 8월 8일 업데이트

Run a structured retrospective after development-phase runs of your product's agents — interview the owner in plain language about what went well and poorly, draft ranked improvement hypotheses, then design and run small n=1/n=2 experiments with pre-declared success criteria, guardrails, stop conditions, and a cost/ROI kill-switch. Load when the user says how did that run go, retro this run, the agent output was bad, what should we improve, draft hypotheses, run a small experiment, or after repeated dev runs of an agentic system produce uneven quality. Priority: output quality over performance over cost, each with diminishing-returns stops. NOT a product A/B test (experimentation), NOT coding-agent harness repair (harness-evolution), NOT production-scale learning (runtime-learning-loop).

한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.

dvy1987/agent-loom32026년 8월 8일 업데이트

Design state-of-the-art multi-agent systems, orchestration patterns, and wiring from scratch. Load when the user asks to build an agent system from scratch, design agent orchestration patterns, choose between sequential/parallel/hierarchical workflows, or define how multiple agents should collaborate. Also triggers on "agent architecture", "multi-agent wiring", "agent orchestration pattern", "how to connect these agents", "design the communication structure". Called by agent-builder for complex topologies (>4 agents or hierarchical). For process-driven agent design, use agent-builder instead.

한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.

dvy1987/agent-loom32026년 8월 8일 업데이트

dvy1987의 스킬 모두 보기

이 스킬의 문제 신고