.agents/skills/adversarial-hat/SKILL.md
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".
npx skillsauth add dvy1987/agent-loom adversarial-hatInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
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.
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.
Run in order — fixing accuracy before challenging solutions prevents wasted effort on flawed foundations.
Phase 1 — Diagnostic: Are claims accurate?
Phase 2 — Creative: Is the problem artificially constrained?
Phase 3 — Challenge: Are solutions actually robust?
product-soul.md → Phase 1 on PMF/strategy claims, Phase 3 on GTM robustnessFor each finding, record: claim challenged · specific critique · severity (Critical/Significant/Minor) · resolution condition
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]
"Shall I add an
## Adversarial Reviewsection to the document with these findings?"
inversion: inversion asks "what is the opposite?" — adversarial hat asks "what is wrong with what we have?"SIGNIFICANT FINDINGS
WHAT WOULD NEED TO BE TRUE
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>
product-soul → after first draft | brainstorming → before writing design doc
prd-writing → after discovery, before writing | inversion → complementary, run both
After completing, always report:
Adversarial review: [document]
Phases run: [D / C / Ch — all or subset]
Critical: N | Significant: N | Minor: N
Integrated into document: [yes / no]
development
Run a fast, read-only health check across all skills in the library and produce a structured quality report — without modifying anything. Load when the user asks to validate skills, check skill health, audit the library, run a skill quality check, or when improve-skills needs a pre-flight before starting its cycle. Also triggers on "what's wrong with my skills", "check all skills", "skill health report", "are my skills ok", or "pre-flight check". Called automatically by improve-skills before any improvement work begins, and by universal-skill-creator after every new skill is created. Never modifies any file — only reads and reports.
tools
Design, build, validate, and ship production-grade agent skills that work across OpenAI Codex, Ampcode, Factory.ai Droids, Google Gemini, Warp, Bolt.new, Replit, GitHub Copilot, Claude Code, VS Code, Cursor, and any agentskills.io compliant platform. Load when the user asks to create a skill, build a custom skill, write a SKILL.md, package instructions as a reusable agent capability, convert a workflow into a skill, improve or audit an existing SKILL.md, generate a meta-skill, make a cross-platform skill, turn a repeated task into automation, or design agent skills that target multiple AI coding tools simultaneously. Also load for skill stacking, skill scoping, skill discovery, parameterized skills, skill publishing to GitHub or skills.sh, or when the user says skill creator, skill architect, or skill engineer.
tools
Identify the right tool for a process step. Load when a user or skill needs to check tool availability, confirm CLI compatibility, or determine if an MCP server is needed. Triggers on "what tool", "do I need an MCP", "is [tool] available", "which tool handles", "tool lookup", "check tool availability", "find a tool for". Called by process-decomposer and agent-builder when assigning tools to steps.
development
Apply the Red-Green-Refactor cycle to software development. Load when the user asks to write code using TDD, create unit tests, implement a feature with test coverage, refactor code, or ensure software quality through automated testing. Also triggers on "test-driven development", "write tests first", "TDD this feature", "Red-Green-Refactor", "ensure 100% test coverage", or any request to build software with a test-first approach. Supports unit, integration, and end-to-end testing strategies.