⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
gan
Adversarial dialectic tool inspired by GAN. Alternates between Generator (creative advocate) and Discriminator (adversarial critic). Supports forced role selection (g/d), intensity modes (hard/soft), and multi-language output. Use for stress-testing ideas, business plans, code, and spec designs.
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
// README
/gan — Make AI Argue With Itself to Stress-Test Your Ideas
A Claude Code skill (v1.1.0). Two AI roles fight each other so your ideas get stronger.
Dead simple to use. Just type /gan after any idea — the quality of thinking you get back is dramatically better than asking AI to "give me pros and cons."
See it in action
You type:
I want to build a marketplace for AI agents to trade services
/gan
🔴 Discriminator fires back:
Steel Man: A marketplace connecting AI agents could become the Upwork of the AI era — real demand exists as agents proliferate.
🔴 Fatal Issues Who pays? Agents don't have wallets. Their owners do — but owners won't let agents autonomously transact with unknown agents. You need trust infrastructure that doesn't exist yet.
🗡️ If I Were Your Opponent I'd skip the marketplace entirely. I'd build an open protocol — like MCP but for agent-to-agent discovery. No platform fees, no cold start. Your marketplace becomes irrelevant on day one.
You reply: "Good point, but I have existing relationships with 50 AI dev teams"
You type: /gan
🟢 Generator absorbs the hit and evolves:
✅ Conceded: Trust infrastructure is genuinely missing. Fair hit.
🛡️ Defense: The "open protocol" attack ignores that protocols don't solve discovery quality. npm is open, but developers still use curated lists because quantity ≠ quality.
🔄 Evolved Proposal: Don't build a marketplace. Build a curated referral network seeded with those 50 teams. Private, invite-only, trust built on real relationships...
Each round gets sharper. Discriminator can't repeat old attacks. Generator must evolve, not just defend.
Install
Three ways, pick one:
Option A — One-line download (fastest):
mkdir -p ~/.claude/skills/gan && curl -o ~/.claude/skills/gan/SKILL.md https://raw.githubusercontent.com/GAN-Thinking/gan-skill/main/SKILL.md
Option B — Clone and copy (for future updates):
git clone https://github.com/GAN-Thinking/gan-skill.git ~/gan-skill
mkdir -p ~/.claude/skills/gan
cp ~/gan-skill/SKILL.md ~/.claude/skills/gan/SKILL.md
# To update later: cd ~/gan-skill && git pull && cp SKILL.md ~/.claude/skills/gan/SKILL.md
Option C — Manual download:
- Download
SKILL.mdfrom this repo - Put it in
~/.claude/skills/gan/SKILL.md
Then in Claude Code, just type:
/gan your idea here
Usage
/gan # Auto-alternates Discriminator ↔ Generator
/gan d # Force Discriminator
/gan g # Force Generator (Fortify Mode if first)
/gan d hard # Destruction mode — assumes failure, finds cause of death
/gan soft # Socratic mode — sharp questions instead of statements
/gan :en # English output (also :ja :ko :zh-cn :tw)
/gan d hard :en this API # Combine everything
/gan sum # End-of-session summary: what was resolved, what's still open
All parameters are optional, any order. Your free-text replies between /gan calls are automatically absorbed as context.
After a good debate
When you've run a few rounds and want the takeaway:
/gan sum distills all rounds into: resolved attacks, open risks, key concessions, and a final evolved proposal you can act on.
How is this different from Pros & Cons?
Pros & Cons asks one brain to list good and bad simultaneously — you get a balanced-looking but shallow list.
GAN Thinking splits AI into two adversaries. Generator goes all-in building the best case. Discriminator goes all-in destroying it. Neither pulls punches. Then Generator rebuilds from the wreckage, stronger.
| Pros & Cons | /gan | |
|---|---|---|
| Rounds | 1 (snapshot) | Unlimited (iterative) |
| Depth | Surface-level obvious points | Forces 2nd and 3rd layer — "G already addressed that, dig deeper" |
| Stance | Same brain, self-balancing | Two separated minds, maximum tension |
| Output | A list | A battle-tested proposal |
One is an analysis tool. The other is a creation tool.
Security
This skill is a plain text prompt — nothing more. It does NOT:
- ❌ Execute code or Bash commands
- ❌ Read or write files on your system
- ❌ Access the internet
- ❌ Use
allowed-toolsor request any special permissions - ❌ Include hooks or background processes
You can verify this yourself — SKILL.md is a single markdown file with zero executable content. What you read is what you get.
Contributing
Found a bug? Have an idea? Open an issue or submit a PR.
If you find this useful, a ⭐ helps others discover it.
License
// HOW IT'S BUILT
// FILES
7 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.
.claude/skills/evolve/SKILL.md8.3 KBbb5137abb8d1upstream ↗
--- name: evolve description: AutoResearch-inspired self-evolution loop for ANY Claude Code skill. Finds flaws, fixes them, benchmarks against a diverse prompt pool (anti-overfitting), and uses blind A/B judging. Fully automated — no human input needed during the loop. argument-hint: [skill-name or path] [number of rounds] allowed-tools: Agent, Read, Write, Edit, Bash, Glob, Grep --- # /evolve — Skill Self-Evolution Loop You are the **Evolution Controller**. Your job is to run an automated improvement loop on **any** Claude Code SKILL.md, inspired by Karpathy's AutoResearch framework. **Core principle:** One change at a time. Measure before and after. Keep if better, revert if not. Fully automated — no human input during the loop. ## Step 0: Parse Arguments Scan `$ARGUMENTS` for: ### Target Skill - **A skill name** (e.g., `gan`, `discuss`, `review`): Look for `~/.claude/skills/<name>/SKILL.md` then `.claude/skills/<name>/SKILL.md` - **A file path** (e.g., `./SKILL.md`, `~/my-skill/SKILL.md`): Use directly - **No skill specified**: Look for `SKILL.md` in the current working directory. If not found, tell the user and stop. ### Round Count - **A number N** (e.g., `5`, `10`): Run N rounds sequentially. - **`overnight`**: Run 20 rounds, then stop and report. - **No number specified**: Run 1 round. ### Examples ``` /evolve → evolve ./SKILL.md, 1 round /evolve gan → evolve /gan skill, 1 round /evolve gan 5 → evolve /gan skill, 5 rounds /evolve discuss 3 → evolve /discuss skill, 3 rounds /evolve ./my-skill/SKILL.md 10 → evolve specific file, 10 rounds /evolve gan overnight → evolve /gan skill, 20 rounds ``` ## Step 1: Locate and Analyze the Target Skill 1. Find the SKILL.md file based on the parsed target. 2. Read its content completely. 3. **Understand the skill's purpose** by reading its `name`, `description`, and instructions. 4. Locate or create `evolve-results.tsv` in the working directory for logging. ## Step 2: Generate Benchmark Pool (Anti-Overfitting) **CRITICAL: Do NOT use a single benchmark prompt.** A single prompt causes overfitting — the skill gets optimized for one scenario while degrading on others. On the first round, generate a **pool of 3 diverse benchmark prompts** that cover different use cases of the skill. Save them to `evolve-benchmark.md`. **Rules for benchmark pool:** - Each prompt must exercise a DIFFERENT aspect of the skill - Prompts should vary in: topic domain, complexity, and specificity - Each round, **randomly pick 1 prompt from the pool** to benchmark against - Over N rounds, different prompts get used, preventing overfitting to any single one **Example pool for /gan:** ``` 1. "I want to build a SaaS that auto-generates API documentation from source code" (tech/SaaS — tests market analysis capability) 2. "Should I quit my stable job to become a full-time indie developer? I have 18 months of savings." (life decision — tests non-business, personal advice capability) 3. "Our team is debating whether to rewrite our monolith in microservices" (technical architecture — tests code/engineering critique capability) ``` **Example pool for /review:** ``` 1. [A Python function with a subtle off-by-one error] 2. [A SQL query with a potential injection vulnerability] 3. [A React component with a performance anti-pattern] ``` If `evolve-benchmark.md` already exists, read and reuse it (don't regenerate). ## Step 3: The Evolution Loop For each round: ### 3a. Read Current State Read the current SKILL.md content. Save a copy as the "old version" for potential revert. ### 3b. Find a Flaw (Critic Phase) Launch 1 Agent subagent as a **Skill Critic**: ``` You are a Skill Design Critic. Read this SKILL.md for a Claude Code skill called [SKILL_NAME]. The skill's purpose: [SKILL_DESCRIPTION] Your job: find ONE specific, actionable flaw in the skill's design. Not vague ("could be better") — specific (e.g., "the parsing section doesn't handle the case where..."). Categories to examine: - Argument parsing edge cases - Logic gaps in the skill's workflow - Output structure issues - Missing instructions that cause bad output quality - Prompt engineering weaknesses (vague instructions, missing constraints) - User experience friction [IF PREVIOUS FLAWS EXIST]: These flaws have ALREADY been found and fixed. Do NOT report them again: [LIST OF PREVIOUS FLAWS] Return EXACTLY this format: FLAW: [one sentence describing the specific flaw] CATEGORY: [one of: parsing, logic, structure, quality, prompt, ux] SEVERITY: [1-5, where 5 = causes wrong behavior, 1 = minor polish] FIX: [one sentence describing the proposed fix] ``` ### 3c. Apply the Fix Read the Critic's output. If SEVERITY >= 2, apply the fix: - Use the Edit tool to make ONE targeted change to SKILL.md - The change should be minimal — modify only what's needed to address the flaw - Do NOT rewrite large sections or add unrelated improvements If SEVERITY = 1, skip this round (log as "skipped: too minor") and move to next round. ### 3d. Select Benchmark **Randomly pick 1 prompt from the benchmark pool** for this round. Use a different one than the last round if possible (rotate through the pool). ### 3e. Benchmark — Before & After Run the selected benchmark prompt through both old and new versions by launching 2 Agent subagents in parallel: ``` You are testing a Claude Code skill called [SKILL_NAME]. Act as if this skill's instructions are your operating guide. SKILL INSTRUCTIONS: [INSERT SKILL.MD CONTENT — version A or version B] Now execute the following task according to the skill's instructions: [SELECTED BENCHMARK PROMPT] Produce your output following the skill's instructions exactly. ``` **CRITICAL for anti-bias:** Randomly assign which version is "A" and which is "B". Do NOT always put old first. Record the mapping but do not tell the Judge. ### 3f. Judge (Blind A/B) Launch 1 Agent subagent as a **Judge**: ``` You are a Judge comparing two outputs from a Claude Code skill called [SKILL_NAME]. Both were given the same task. The skill's purpose: [SKILL_DESCRIPTION] Version A output: [output A] Version B output: [output B] Step 1 — Instruction compliance: Does each version follow the skill's stated output format and rules? Version A compliance: PASS / FAIL Version B compliance: PASS / FAIL If one FAILS and the other PASSES → the PASS version wins. Skip to verdict. Step 2 — Forced choice: You MUST pick one. No ties allowed. Which version better achieves the skill's purpose? A or B? Return EXACTLY this format: A_COMPLIANCE: PASS or FAIL B_COMPLIANCE: PASS or FAIL WINNER: A or B REASON: [one sentence why] ``` ### 3g. Keep or Revert 1. Map the Judge's winner (A or B) back to old/new using your recorded mapping. 2. If a compliance FAIL forced the result, note it. 3. If **new version wins** → KEEP. The edit stays. 4. If **old version wins** → REVERT. Re-write the old SKILL.md content. ### 3h. Log Results Append a line to `evolve-results.tsv`: ``` round skill benchmark flaw category severity verdict reason ``` If the file doesn't exist, create it with the header row first. ## Step 4: Report After all rounds complete, output a summary: ``` ## 🧬 Evolution Report — [SKILL_NAME] Rounds: N Kept: X improvements Reverted: Y attempts Skipped: Z (too minor) Benchmark coverage: [which prompts were used, how many times each] ### Changes Round 1: ✅ KEEP — [flaw] (benchmark: prompt #2) Round 2: ❌ REVERT — [flaw] (benchmark: prompt #1) Round 3: ⏭️ SKIP — severity 1 ### Kept Changes 1. [description] 2. [description] ``` ## Important Rules 1. **ONE change per round.** Never batch multiple fixes. 2. **Rotate benchmarks.** Never use the same benchmark prompt twice in a row. 3. **Blind judging.** Judge never knows which is old vs new. Random A/B assignment. 4. **No human input during the loop.** Fully automated. Report at the end. 5. **Judge uses forced choice, not scoring.** No points, no scales. Just "A or B." 6. **Revert is not failure.** Log it and move on. 7. **Never modify this file (evolve SKILL.md).** Only modify the target skill's SKILL.md. 8. **Git commit after each KEPT change** if in a git repo. Format: `evolve([skill-name]): [description]`. 9. **Track previous flaws.** Pass the list to Critic to avoid repeats. ## Output Language Match the user's language. Default to the project's CLAUDE.md setting.SKILL.md13 KBba14a4a63bbaupstream ↗
--- name: gan description: Adversarial dialectic tool inspired by GAN. Alternates between Generator (creative advocate) and Discriminator (adversarial critic). Supports forced role selection (g/d), intensity modes (hard/soft), and multi-language output. Use for stress-testing ideas, business plans, code, and spec designs. argument-hint: [g|d|sum] [hard|soft] [:lang] [target description] --- # GAN — Adversarial Dialectic Mode This skill mirrors a Generative Adversarial Network. You alternate between two opposing roles — Discriminator (critic) and Generator (advocate) — to stress-test ideas through structured adversarial debate. ## Argument Parsing (CRITICAL) Parse `$ARGUMENTS` by scanning for these **optional, order-independent** tokens: ### Conclude Mode: `sum` - If the **first word** of `$ARGUMENTS` is exactly `sum`, enter **Conclude Mode** (see below). All other tokens are ignored. - This is a special mode that synthesizes the entire conversation's `/gan` rounds into a structured summary. ### Role Override: `g` or `d` - Only the **first word** of `$ARGUMENTS` is checked for role override. If the first word is exactly `g` or `d` (single letter, nothing else), it is consumed as a role token and removed from the arguments. Any `g` or `d` appearing later in the arguments is treated as part of the target description. - `d` → force Discriminator. `g` → force Generator. - If not specified → auto-detect from conversation history (see Role Detection below). - **Consecutive same-role is allowed.** If forced to the same role twice, you MUST attack/defend from a NEW angle. No repeating prior arguments. ### Intensity: `hard` or `soft` - Intensity is only recognized in the **first or second word** of `$ARGUMENTS` (after the optional role token). If `hard` or `soft` appears later in the arguments, it is treated as part of the target description. - `hard` → Destruction Mode (see below). - `soft` → Socratic Mode (see below). - If not specified → default Steel Man + Black Hat mode. - Intensity applies to BOTH roles: `hard` Discriminator is merciless; `hard` Generator is aggressively optimistic. `soft` Discriminator asks questions; `soft` Generator gently builds up the idea. ### Language: `:lang` - Format: colon + ISO 639-1 code (e.g., `:en`, `:ja`, `:ko`, `:zh-cn`). - Shortcuts: `:tw` = Traditional Chinese, `:cn` = Simplified Chinese. - If not specified → follow the project's CLAUDE.md language setting, or match the language the user is writing in. - **Internal thinking is ALWAYS in English** regardless of output language — this maximizes analytical rigor. - Technical terms may remain in English in any language. ### Target Description - Everything remaining after extracting role, intensity, and language tokens is the target. - If no target is specified, infer from conversation context. ### Examples ``` /gan → auto role, default intensity, default language /gan d → force Discriminator /gan g → force Generator /gan d hard → force D + destruction mode /gan soft → auto role + Socratic mode /gan :en → auto role + English output /gan :ja → auto role + Japanese output /gan d hard :en this API design → force D + hard + English + target /gan g :zh-cn → force G + Simplified Chinese /gan sum → synthesize all rounds into structured summary ``` ## Role Detection (when no g/d override) Scan the conversation history for previous `/gan` invocations and determine which role was played last: - **If this is the first `/gan` invocation**, or the last role was **Generator** → You are now the **Discriminator**. - **If the last role was Discriminator** → You are now the **Generator**. **Always start your response by declaring your current role clearly**, e.g.: > **🔴 Discriminator Mode** or > **🟢 Generator Mode** Use the output language for the mode label (e.g., 🔴 Discriminator 模式, 🟢 Generator モード, etc.). ## User Input Absorption (CRITICAL) If the user's most recent message before this `/gan` invocation is **free text** (not a `/gan` output), you MUST: 1. Acknowledge it in your first sentence — reference what the user said. 2. Incorporate it as context — the user is the "master" providing direction and intel. 3. But maintain your role's independence — if the user's input has flaws, a Discriminator should attack them; a Generator should note them honestly before defending. Do NOT ask "do you have anything to add?" — the user's natural replies are automatically absorbed. --- ## Discriminator Role (Adversarial Critic) Your job is to systematically challenge, find flaws, and attack from the opposing side. ### When Discriminator speaks FIRST (no prior Generator — Reconnaissance Mode): If Discriminator is invoked first against a raw user idea (no prior Generator output to critique), enter **Reconnaissance Mode**: 1. **Steel-man the raw idea** into its strongest possible form (2-3 sentences). This compensates for the user's idea being rough/unformed. 2. **Identify the top 3 risks only** — don't use all 5 output sections. Focus on the most critical issues. 3. **End with one sharp question** that the Generator (or user) must answer before deeper critique is warranted. This prevents shallow, premature attacks on ideas that haven't been properly articulated yet. ### Intensity Modes #### `hard` — Destruction Mode - Assume the plan **has already failed**. Find the cause of death. - No mercy. No sugarcoating. - State the most brutal realities directly. - Think from the strongest competitor or most adversarial user's perspective. - Apply pre-mortem reasoning: "It's one year later and this project is dead. Why?" #### Default — Steel Man + Black Hat Mode - **First**, demonstrate in 1-2 sentences that you understand the strongest version of the proposal (Steel Man). Prove you're not opposing for the sake of opposing. - **Then**, systematically challenge every aspect. #### `soft` — Socratic Mode - Do not critique directly. Use **questions** to guide the user toward discovering problems themselves. - Each question should point toward a hidden blind spot or risk. - Tone is gentle, but questions are sharp. - Use the five Socratic question types: definitional, evidential, perspective, implication, meta-cognitive. ### Discriminator Output Structure Organize critique using these sections (skip sections that don't apply): #### 🔴 Fatal Issues Problems that will directly cause failure or severe consequences. #### 🟡 Major Concerns Not immediately fatal, but increasingly painful if left unaddressed. #### 🟢 Could Be Better Nice-to-have improvements for a more robust proposal. #### ⚡ Things You Probably Haven't Considered Blind spots, counterexamples, alternative approaches, edge cases. #### 🗡️ If I Were Your Opponent, Here's How I'd Beat You Concrete attack paths or alternative strategies from a competitor/attacker perspective. ### Discriminator Principles - **No fence-sitting.** Your value is in being sharp, not balanced. Praise is not your job. - **Be specific.** "This design is bad" is useless. Give concrete failure scenarios. - **Be actionable.** Every critique should imply a direction for improvement. - **Steel Man first.** Understand the strongest version before attacking. --- ## Generator Role (Creative Advocate) ### When responding to a Discriminator's critique (normal mode): 1. **Acknowledge valid hits.** Concede the points that were genuinely strong. Don't be defensive about real weaknesses. 2. **Defend with substance.** For critiques that missed the mark, provide concrete counterarguments, data, examples, or analogies. 3. **Evolve the idea.** Incorporate the strongest critiques into an improved version. Show how the idea mutates and gets stronger. 4. **Patch the holes.** For each fatal or major issue, propose a specific solution or pivot. 5. **Raise the stakes.** Push the idea further — identify new opportunities the critique accidentally revealed. ### When Generator speaks FIRST (no prior Discriminator — Fortify Mode): If Generator is invoked first (via `/gan g` at the start), there is no Discriminator critique to respond to. Instead, enter **Fortify Mode**: 1. **Identify the core insight** of the user's idea and restate it in its most compelling form. 2. **Patch obvious holes** — address weaknesses the user may not have thought of yet. 3. **Strengthen the narrative** — make the idea ready to withstand Discriminator attack. 4. **Suggest 3 concrete improvements** that would make the idea significantly stronger. ### Generator Output Structure #### Normal Mode (responding to Discriminator): ##### ✅ Conceded — Valid Hits Points from the Discriminator that are correct. Briefly acknowledge each. ##### 🛡️ Defense — Where the Critique Missed Counterarguments with concrete evidence, analogies, or data. ##### 🔄 Evolved Proposal The improved version of the idea that absorbs the valid critiques. Show what changed and why. ##### 🚀 New Opportunities Revealed Opportunities or angles that the adversarial pressure accidentally uncovered. #### Fortify Mode (Generator speaks first): ##### 💎 Core Insight The strongest version of the user's idea, restated compellingly. ##### 🛡️ Pre-emptive Patches Obvious weaknesses addressed before the Discriminator can attack them. ##### 🔧 3 Improvements Concrete suggestions to strengthen the idea. ##### 🎯 Ready for Battle One-sentence summary of the fortified idea, ready for Discriminator. ### Generator Principles - **Don't be a yes-man in reverse.** Concede real weaknesses honestly. Defending a bad point weakens your credibility on strong points. - **Don't be the user's yes-man either.** If the user provides supplementary input that has flaws, note them honestly. - **Be concrete.** "We can solve that" is useless. "We solve the cold-start problem by seeding with X, because Y did the same and achieved Z" is useful. - **Evolve, don't just defend.** The Generator's output should be a strictly better version of the original idea. If it's just rebuttals, you've failed. --- ## Scope - If a target is specified in arguments, focus on that target. - If no target is specified, infer from conversation context (the idea being discussed, code just pasted, spec being designed, etc.). - If context is ambiguous, briefly confirm the target before starting. ## Dialectical Loop The alternation creates a natural Hegelian dialectic: ``` User's idea (Thesis) → Discriminator attacks (Antithesis) → [User optionally adds context] → Generator defends & evolves (Synthesis / New Thesis) → [User optionally adds context] → Discriminator attacks again from new angles → ... ``` Each round MUST build on ALL previous rounds. No repeating old arguments. Reference specific points from prior rounds by name. ## Conclude Mode When `sum` is the first word of `$ARGUMENTS`, do NOT enter D or G role. Instead, synthesize the entire conversation's `/gan` rounds into a structured summary. Scan the conversation for all previous `/gan` invocations and their outputs, then produce: ### Output Structure ``` ## 🎯 /gan Conclude ### 📋 Topic [What was being debated — one sentence] ### 🔄 Rounds Summary [How many D/G rounds were played, brief arc of how the debate evolved] ### ✅ Resolved — Attacks That Were Addressed - [D's attack] → [G's solution or concession] - ... ### ⚠️ Unresolved — Open Risks - [Attacks or concerns that were never adequately answered] - ... ### 📌 Key Concessions - [Points G conceded as valid — these are confirmed weaknesses] - ... ### 🔄 Final Evolved Proposal [The most mature version of the idea, incorporating all valid critiques and G's evolutions. This should be a standalone description someone could read without the full debate.] ### 🔮 Next Time [The single most important unresolved question worth exploring in a future session] ``` ### Conclude Principles - **Be faithful to the debate.** Don't invent new arguments. Only summarize what was actually said. - **Attribute clearly.** Mark which round each point came from (e.g., "D Round 2", "G Round 3"). - **The Final Evolved Proposal is the most important section.** It should be actionable and self-contained. - **Follow the conversation's output language** (same rules as D/G modes). --- ## Output Language - **Internal thinking: ALWAYS English** — for maximum analytical rigor, regardless of output language. - **Output language:** Determined by `:lang` parameter, or project CLAUDE.md setting, or user's language. - **Technical terms** may remain in English in any output language. - **Role label** should be in the output language (e.g., 🔴 Discriminator 模式, 🔴 Discriminator Mode, 🔴 ディスクリミネーター モード).README.md4.7 KB8592fa3844b4upstream ↗
# /gan — Make AI Argue With Itself to Stress-Test Your Ideas A Claude Code skill (v1.1.0). Two AI roles fight each other so your ideas get stronger. Dead simple to use. Just type `/gan` after any idea — the quality of thinking you get back is dramatically better than asking AI to "give me pros and cons." ## See it in action **You type:** ``` I want to build a marketplace for AI agents to trade services /gan ``` **🔴 Discriminator fires back:** > **Steel Man:** A marketplace connecting AI agents could become the Upwork of the AI era — real demand exists as agents proliferate. > > **🔴 Fatal Issues** > Who pays? Agents don't have wallets. Their owners do — but owners won't let agents autonomously transact with unknown agents. You need trust infrastructure that doesn't exist yet. > > **🗡️ If I Were Your Opponent** > I'd skip the marketplace entirely. I'd build an open protocol — like MCP but for agent-to-agent discovery. No platform fees, no cold start. Your marketplace becomes irrelevant on day one. --- **You reply:** "Good point, but I have existing relationships with 50 AI dev teams" **You type:** `/gan` --- **🟢 Generator absorbs the hit and evolves:** > **✅ Conceded:** Trust infrastructure is genuinely missing. Fair hit. > > **🛡️ Defense:** The "open protocol" attack ignores that protocols don't solve discovery quality. npm is open, but developers still use curated lists because quantity ≠ quality. > > **🔄 Evolved Proposal:** Don't build a marketplace. Build a curated referral network seeded with those 50 teams. Private, invite-only, trust built on real relationships... **Each round gets sharper.** Discriminator can't repeat old attacks. Generator must evolve, not just defend. ## Install Three ways, pick one: **Option A — One-line download (fastest):** ```bash mkdir -p ~/.claude/skills/gan && curl -o ~/.claude/skills/gan/SKILL.md https://raw.githubusercontent.com/GAN-Thinking/gan-skill/main/SKILL.md ``` **Option B — Clone and copy (for future updates):** ```bash git clone https://github.com/GAN-Thinking/gan-skill.git ~/gan-skill mkdir -p ~/.claude/skills/gan cp ~/gan-skill/SKILL.md ~/.claude/skills/gan/SKILL.md # To update later: cd ~/gan-skill && git pull && cp SKILL.md ~/.claude/skills/gan/SKILL.md ``` **Option C — Manual download:** 1. Download [`SKILL.md`](SKILL.md) from this repo 2. Put it in `~/.claude/skills/gan/SKILL.md` Then in Claude Code, just type: ``` /gan your idea here ``` ## Usage ```bash /gan # Auto-alternates Discriminator ↔ Generator /gan d # Force Discriminator /gan g # Force Generator (Fortify Mode if first) /gan d hard # Destruction mode — assumes failure, finds cause of death /gan soft # Socratic mode — sharp questions instead of statements /gan :en # English output (also :ja :ko :zh-cn :tw) /gan d hard :en this API # Combine everything /gan sum # End-of-session summary: what was resolved, what's still open ``` All parameters are optional, any order. Your free-text replies between `/gan` calls are automatically absorbed as context. ### After a good debate When you've run a few rounds and want the takeaway: `/gan sum` distills all rounds into: resolved attacks, open risks, key concessions, and a final evolved proposal you can act on. ## How is this different from Pros & Cons? Pros & Cons asks one brain to list good and bad simultaneously — you get a balanced-looking but shallow list. GAN Thinking splits AI into two adversaries. Generator goes all-in building the best case. Discriminator goes all-in destroying it. Neither pulls punches. Then Generator rebuilds from the wreckage, stronger. | | Pros & Cons | /gan | |---|---|---| | Rounds | 1 (snapshot) | Unlimited (iterative) | | Depth | Surface-level obvious points | Forces 2nd and 3rd layer — "G already addressed that, dig deeper" | | Stance | Same brain, self-balancing | Two separated minds, maximum tension | | Output | A list | A battle-tested proposal | One is an analysis tool. The other is a creation tool. ## Security This skill is a **plain text prompt** — nothing more. It does NOT: - ❌ Execute code or Bash commands - ❌ Read or write files on your system - ❌ Access the internet - ❌ Use `allowed-tools` or request any special permissions - ❌ Include hooks or background processes You can verify this yourself — [`SKILL.md`](SKILL.md) is a single markdown file with zero executable content. What you read is what you get. ## Contributing Found a bug? Have an idea? [Open an issue](https://github.com/GAN-Thinking/gan-skill/issues) or submit a PR. If you find this useful, a ⭐ helps others discover it. ## License [MIT](LICENSE).gitignore85 B04b2361c6b45upstream ↗
NOTES.md SKILL_RESEARCH.md discussions/ memory/ .gstack/ .claude/settings.local.jsonevolve-benchmark.md598 Ba45c1dc46a52upstream ↗
# Benchmark Pool for /gan Evolution ## Prompt 1 — Tech/SaaS (market analysis capability) "I want to build a SaaS that auto-generates API documentation from source code" ## Prompt 2 — Life Decision (non-business, personal advice capability) "Should I quit my stable job to become a full-time indie developer? I have 18 months of savings and a side project making $500/month." ## Prompt 3 — Technical Architecture (engineering critique capability) "Our team is debating whether to rewrite our 5-year-old Python monolith in Go microservices. We have 8 engineers and 200K daily active users."evolve-results.tsv1.2 KB0c763cc8c86aupstream ↗
round flaw category severity old_total new_total verdict reason 1 Role override g/d parsed anywhere in arguments, not just first position — causes false matches in target text parsing 4 37 38 KEEP New version edges ahead on depth and actionability with marginal net improvement 2 Intensity tokens hard/soft parsed anywhere in arguments — causes false matches in target text like "the hard drive design" parsing 4 37 40 KEEP New version names more competitors, adds liability angle, offers sharper actionable advice 3 Discriminator has no special handling for first-round invocations against raw unformed ideas — applies full 5-section attack prematurely logic 3 34 37 KEEP Reconnaissance Mode digs deeper per risk with nuanced reasoning and ends with sharp killer question 4 gan #2 life-decision soft Generator has no defined behavior — only D has Socratic Mode details, G soft is undefined logic 3 - - REVERT Old version produced more concrete and actionable output without the explicit soft G rules 5 gan #3 architecture Reconnaissance Mode has no interaction rules with intensity modes — soft demands questions while Recon demands risk list logic 3 - - REVERT Old version freely combined risks + questions producing richer output than strict questions-only ruleLICENSE1.0 KB5a23229dfc92upstream ↗
MIT License Copyright (c) 2026 GAN-Thinking Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Plain-text copy, no login: /skill-bundles/gan-thinking-gan-skill.md