# gan

Adopt this skill: https://proskills.md/skills/other/gan-thinking-gan-skill

Page: https://proskills.md/skills/other/gan-thinking-gan-skill
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: .claude/skills/evolve/SKILL.md
size: 8492
sha: bb5137abb8d14b6771e8357287ae6cd3abd54daf
upstream: https://github.com/gan-thinking/gan-skill/blob/HEAD/.claude/skills/evolve/SKILL.md

````text
---
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.
````

## File: SKILL.md
size: 13048
sha: ba14a4a63bba736c0fdd1f8842b4b6c2947b5cf5
upstream: https://github.com/gan-thinking/gan-skill/blob/HEAD/SKILL.md

````text
---
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, 🔴 ディスクリミネーター モード).
````

## File: README.md
size: 4822
sha: 8592fa3844b478f1be388e68a2efc66f30fc3bbc
upstream: https://github.com/gan-thinking/gan-skill/blob/HEAD/README.md

````text
# /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)
````

## File: .gitignore
size: 85
sha: 04b2361c6b454a7a1d780597be87ef7adfff90c7
upstream: https://github.com/gan-thinking/gan-skill/blob/HEAD/.gitignore

```text
NOTES.md
SKILL_RESEARCH.md
discussions/
memory/
.gstack/
.claude/settings.local.json
```

## File: evolve-benchmark.md
size: 598
sha: a45c1dc46a523fa7c729fe68d7a60dfe732a7ceb
upstream: https://github.com/gan-thinking/gan-skill/blob/HEAD/evolve-benchmark.md

```text
# 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."
```

## File: evolve-results.tsv
size: 1275
sha: 0c763cc8c86a7ba0580cdb494bc1408b44065d46
upstream: https://github.com/gan-thinking/gan-skill/blob/HEAD/evolve-results.tsv

```text
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 rule
```

## File: LICENSE
size: 1069
sha: 5a23229dfc92987c6d72aaac82210eddc075c4bc
upstream: https://github.com/gan-thinking/gan-skill/blob/HEAD/LICENSE

```text
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.
```
