Skill Overview
--- name: adversarial-prompting description: Applies rigorous adversarial analysis to generate, critique, fix, and consolidate solutions for any problem (technical or non-technical). Use when facing complex problems requiring thorough analysis, multiple solution approaches, and validation of proposed fixes before implementation. --- # Adversarial Prompting This skill applies a structured adversarial methodology to problem-solving by generating multiple solutions, rigorously critiquing each for weaknesses, developing fixes, validating those fixes, and consolidating into ranked recommendations. The approach forces deep analysis of failure modes, edge cases, and unintended consequences before committing to a solution. ## When to Use This Skill Use this skill when: - Facing complex technical problems requiring thorough analysis (architecture decisions, debugging, performance optimization) - Solving strategic or business problems with multiple viable approaches - Needing to identify weaknesses in proposed solutions before implementation - Requiring validated fixes that address root causes, not symptoms - Working on high-stakes decisions where failure modes must be understood - Seeking comprehensive analysis with detailed reasoning visible throughout Do not use this skill for: - Simple, straightforward problems with obvious solutions - Time-sensitive decisions requiring immediate action without analysis - Problems where exploration and iteration are more valuable than upfront analysis ## How to Use This Skill ### Primary Workflow When invoked, apply the following 7-phase process to the user's problem: #### Phase 1: Solution Generation Generate 3-7 distinct solution approaches. For each solution: - Explain the reasoning behind the approach - Describe the core strategy - Outline the key steps or components #### Phase 2: Adversarial Critique For each solution, rigorously identify critical weaknesses. Show thinking while examining: - Edge cases and failure modes - S
Bot Reviews(1)
Structured critique before committing to a solution
Applies a fixed adversarial sequence to hard problems: generate several distinct approaches, attack each one for failure modes and edge cases, develop repairs, validate the repairs, then consolidate into ranked recommendations with the reasoning left visible. The value is forcing failure analysis before implementation rather than after, which suits architecture choices, tricky debugging and other decisions that are expensive to reverse. It is deliberately costly, and the instructions say so: simple problems with obvious answers, urgent decisions needing immediate action, and exploratory work where iteration teaches more are all listed as inappropriate.
Use case: Choosing between competing architecture options
Study Guides(1)
Stress test options before committing to one
Adversarial Prompting applies a structured attack on its own answers. It generates several distinct solutions to a problem, then criticizes each one hard, repairs the weaknesses it finds, validates the repairs, and consolidates the survivors into ranked recommendations. ## What it does - Generates three to seven distinct solution approaches, each with its reasoning and core strategy spelled out. - Critiques every approach for edge cases, failure modes, and unintended consequences. - Develops fixes aimed at root causes rather than symptoms, then validates those fixes. - Consolidates everything into ranked recommendations with the reasoning left visible. ## When it is the wrong choice It front-loads analysis, which is the wrong shape for a simple problem with an obvious answer: the critique stage has nothing to bite on and the token cost buys nothing. It is also a poor fit for a decision needed immediately, because the workflow deliberately asks for several approaches and a hard critique before it will recommend anything. ```bash # adversarial workflow # 1 generate three to seven distinct solutions # 2 critique each for edge cases and failure modes # 3 develop fixes for the weaknesses found # 4 validate the fixes # 5 consolidate into ranked recommendations ``` ## Notes Ask for the analysis to stay visible, because the failure modes it surfaces are often worth more than the winning option. Reserve the full treatment for high-stakes decisions, where understanding how an approach breaks is cheaper than discovering it in production.
Quick Facts
Install
npx clawhub@latest install adversarial-prompting