Redteam

Customization

Before executing, check for user customizations at: ~/.claude/PAI/USER/SKILLCUSTOMIZATIONS/RedTeam/

If this directory exists, load and apply any PREFERENCES.md, configurations, or resources found there. These override default behavior. If the directory does not exist, proceed with skill defaults.

🚨 MANDATORY: Voice Notification (REQUIRED BEFORE ANY ACTION)

You MUST send this notification BEFORE doing anything else when this skill is invoked.

1. Send voice notification:

   curl -s -X POST http://localhost:31337/notify \
     -H "Content-Type: application/json" \
     -d '{"message": "Running the WORKFLOWNAME workflow in the RedTeam skill to ACTION"}' \
     > /dev/null 2>&1 &

2. Output text notification:

   Running the **WorkflowName** workflow in the **RedTeam** skill to ACTION...

This is not optional. Execute this curl command immediately upon skill invocation.

RedTeam Skill

Military-grade adversarial analysis using parallel agent deployment. Breaks arguments into atomic components, attacks from 32 expert perspectives (engineers, architects, pentesters, interns), synthesizes findings, and produces devastating counter-arguments with steelman representations.

Workflow Routing

Route to the appropriate workflow based on the request.

When executing a workflow, output this notification directly:

Running the **WorkflowName** workflow in the **RedTeam** skill to ACTION...

---

Quick Reference

The Five-Phase Protocol (ParallelAnalysis): 1. Decomposition - Break into 24 atomic claims 2. Parallel Analysis - 32 agents examine strengths AND weaknesses 3. Synthesis - Identify convergent insights 4. Steelman - Strongest version of the argument 5. Counter-Argument - Strongest rebuttal

---

Context Files

• Philosophy.md - Core philosophy, success criteria, agent types
• Integration.md - Skill integration, FirstPrinciples usage, output format

---

Examples

Attack an architecture proposal:

User: "red team this microservices migration plan"
--> Workflows/ParallelAnalysis.md
--> Returns steelman + devastating counter-argument (8 points each)

Devil's advocate on a business decision:

User: "poke holes in my plan to raise prices 20%"
--> Workflows/ParallelAnalysis.md
--> Surfaces the ONE core issue that could collapse the plan

Adversarial validation for content:

User: "battle of bots - which approach is better for this feature?"
--> Workflows/AdversarialValidation.md
--> Synthesizes best solution from competing ideas

---

Last Updated: 2025-12-20

Gotchas

• RedTeam is for attacking IDEAS, not systems. This skill finds flaws in arguments, strategies, and plans — not network vulnerabilities.
• 32 adversarial agents generate volume — not all findings are equal. Rank by severity, discard noise.
• The goal is to strengthen, not destroy. Present weaknesses constructively with remediation paths.

Execution Log

After completing any workflow, append a single JSONL entry:

echo '{"ts":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","skill":"RedTeam","workflow":"WORKFLOW_USED","input":"8_WORD_SUMMARY","status":"ok|error","duration_s":SECONDS}' >> ~/.claude/PAI/MEMORY/SKILLS/execution.jsonl

Replace WORKFLOW_USED with the workflow executed, 8_WORD_SUMMARY with a brief input description, and SECONDS with approximate wall-clock time. Log status: "error" if the workflow failed.

Red Team Integration Guide

Skill Integration Order

Use BEFORE RedTeam:

• research - Gather context, find precedents

Use DURING RedTeam:

• storyexplanation - Decomposition methodology
• Custom Agents (via Agents skill) - Parallel assault

Use AFTER RedTeam:

• extractalpha - Highest-signal critiques
• xpost - Share findings

FirstPrinciples Integration

RedTeam deeply integrates with FirstPrinciples skill:

• Phase 1 Enhancement: Use FirstPrinciples/Deconstruct to break arguments into fundamental parts
• Phase 5 Enhancement: Use FirstPrinciples/Challenge to classify constraints as hard/soft/assumption
• Core Insight: The most devastating critiques come from challenging hidden assumptions
• Invocation: "Use FirstPrinciples/Challenge on the stated constraints before parallel analysis"

Output Format

• Format: Steelman + Counter-argument, each with 8 numbered points
• Length: 12-16 words per point (strict discipline)
• Tone: Direct, substantive, non-performative
• Must Include: First-principles analysis, convergence identification
• Must Avoid: Nitpicking, strawmanning, generic objections

---

Last Updated: 2025-12-20

Red Team Philosophy

Origin

Military red teaming - dedicated teams that attack plans, strategies, and assumptions to find vulnerabilities before the enemy does.

Core Insight

The goal is NOT destruction - it's finding the fundamental flaw that, if challenged, causes the entire structure to collapse.

The most powerful critique is usually ONE core issue:

• A hidden assumption that's actually false
• A logical step that doesn't follow
• A category error (treating X like Y)
• An ignored precedent that directly contradicts

Success Criteria

• Steelman is strong enough that a proponent would say "yes, that's my argument"
• Counter-argument defeats the steelman, not a weaker strawman
• Multiple agents converged on same insights
• Reader says "I hadn't thought of that"

The 32 Agent Types

Each agent type brings unique attack angles - see Workflows/ParallelAnalysis.md for full roster.

---

Last Updated: 2025-12-20

Adversarial Validation Pattern (Battle of Bots)

Voice Notification

curl -s -X POST http://localhost:31337/notify \
  -H "Content-Type: application/json" \
  -d '{"message": "Running the AdversarialValidation workflow in the RedTeam skill to validate decisions"}' \
  > /dev/null 2>&1 &

Running the AdversarialValidation workflow in the RedTeam skill to validate decisions...

Purpose: Use competing agents + critic to produce superior synthesis through adversarial refinement.

When to Use:

• Feature specifications that need stress-testing
• Architectural decisions before implementation
• Code reviews where multiple approaches exist
• Content that needs to withstand scrutiny
• Any output where quality matters more than speed

Source: Network Chuck prompting video (2025) - "AI is normally better at critiquing or editing than original writing"

---

The Three-Round Protocol

Round 1: Competing Proposals

Launch 2-3 specialized agents to produce competing solutions from different perspectives:

<instructions>
ADVERSARIAL VALIDATION - ROUND 1 (COMPETING PROPOSALS):

You are [PERSONA]. Generate your best solution to this problem.

Your perspective emphasizes:
- [Key concern 1]
- [Key concern 2]
- [Key concern 3]

Produce a complete solution that optimizes for YOUR priorities.
Be specific and detailed - this will be compared against other proposals.
</instructions>

[Problem/Task description]

Suggested Persona Combinations:

For Architecture Decisions:

• Engineer (implementation ease, maintainability)
• Architect (scalability, patterns, long-term)
• Security (attack surface, vulnerabilities)

For Feature Specs:

• Product (user value, simplicity)
• Engineer (feasibility, complexity)
• QA (testability, edge cases)

For Content/Writing:

• Subject Matter Expert (accuracy, depth)
• Audience Representative (clarity, engagement)
• Editor (structure, flow)

Round 2: Brutal Critique

A critic agent reads ALL proposals and "brutally critiques" each:

<instructions>
ADVERSARIAL VALIDATION - ROUND 2 (BRUTAL CRITIQUE):

You are the Harsh Critic. You have received [N] proposals for [problem].

For EACH proposal:

1. **What they got RIGHT:**
   - Acknowledge genuine strengths (be specific)

2. **What they got WRONG:**
   - Identify flaws, gaps, weaknesses
   - Point out what they conveniently ignored
   - Highlight where their perspective blinds them

3. **The Uncomfortable Truth:**
   - What none of them want to hear?
   - What's the real problem they're all dancing around?

4. **If forced to pick one:**
   - Which has the strongest foundation?
   - Why?

Be harsh but fair. The goal is truth, not destruction.
</instructions>

[Proposals from Round 1]

Round 3: Collaborative Synthesis

The original agents read the critique and collaborate on a final solution:

<instructions>
ADVERSARIAL VALIDATION - ROUND 3 (COLLABORATIVE SYNTHESIS):

You are [PERSONA]. You've seen the Critic's brutal assessment.

Working with your fellow agents, produce a SINGLE UNIFIED solution that:
- Addresses the valid criticisms
- Incorporates the best elements from each proposal
- Resolves the tensions between perspectives
- Acknowledges remaining trade-offs honestly

This is not compromise - it's synthesis. The final output should be BETTER
than any individual proposal, not just a blend.
</instructions>

[Original proposals + Critic's assessment]

---

Complete Adversarial Validation Template

For a single-prompt execution:

<instructions>
ADVERSARIAL VALIDATION - FULL PROTOCOL:

ROUND 1 - COMPETING PROPOSALS:
Generate 3 distinct solutions to this problem from different perspectives:

Proposal A (Pragmatist): Prioritizes ease of implementation and quick wins
Proposal B (Idealist): Prioritizes best practices and long-term quality
Proposal C (Skeptic): Prioritizes risk reduction and failure prevention

Each proposal should be complete and defensible.

ROUND 2 - BRUTAL CRITIQUE:
As a harsh but fair critic, evaluate all three proposals:
- What each got right
- What each got wrong
- The uncomfortable truth none addressed
- Which has the strongest foundation

ROUND 3 - COLLABORATIVE SYNTHESIS:
Synthesize the best elements into a single superior solution that:
- Addresses the valid criticisms
- Incorporates strengths from each proposal
- Resolves tensions between perspectives
- Honestly acknowledges remaining trade-offs

OUTPUT:
- Brief summary of the three proposals
- Key critique points
- Final synthesized recommendation with clear rationale
</instructions>

[Problem/Task to validate]

---

Integration with Existing RedTeam

Relationship to 32-Agent Protocol:

• The 32-agent parallel analysis (parallelAnalysis.md) is for DEPTH - attacking one argument from 32 perspectives
• Adversarial Validation is for SYNTHESIS - producing better output through competition and refinement

When to Use Which:

• 32-Agent Protocol: "Red team this argument/idea" - stress-test existing content
• Adversarial Validation: "Help me design/decide/create X" - produce new content through adversarial refinement

Combining Both: 1. Use Adversarial Validation to produce initial solution 2. Use 32-Agent Protocol to stress-test the synthesized result 3. Iterate if critical flaws found

---

Quality Signals

Good Adversarial Validation:

• Each proposal genuinely represents its perspective (not strawmen)
• Critic finds real flaws, not just nitpicks
• Synthesis is demonstrably better than any individual proposal
• Trade-offs are honestly acknowledged
• Final output withstands scrutiny

Bad Signs:

• Proposals are too similar (not enough diversity)
• Critic is too gentle or too destructive
• "Synthesis" is just one proposal with minor tweaks
• Trade-offs are handwaved away
• Adversarial process feels performative

---

Example: API Design Decision

Problem: "Design authentication flow for our new API"

Round 1 Proposals:

Proposal A (Pragmatist): JWT with 24-hour expiry, refresh tokens, standard claims. Quick to implement, well-understood pattern.

Proposal B (Idealist): OAuth 2.0 with PKCE, short-lived access tokens (15 min), secure token storage, audit logging. Industry best practice.

Proposal C (Skeptic): API keys with rate limiting, IP allowlisting, manual rotation. Minimal attack surface, easy to revoke.

Round 2 Critique:

• A is fast but JWT secrets are hard to rotate, 24h is too long
• B is gold standard but massive implementation overhead for current team size
• C is secure but doesn't scale to public API use case

Uncomfortable truth: None addressed the question of "what happens when we NEED to revoke all tokens immediately?"

Round 3 Synthesis:

Start with A's JWT approach (pragmatic), add B's short-lived tokens (15 min) and audit logging (security), implement C's emergency revocation list (skeptic's concern). Defer full OAuth until public API launch.

---

Key Principles

1. Genuine competition - Proposals must represent real alternatives, not strawmen 2. Brutal but fair critique - Find real flaws, acknowledge real strengths 3. Synthesis > Compromise - The goal is BETTER, not BLENDED 4. Honest trade-offs - Don't pretend tensions are fully resolved 5. Permission to fail applies - If no synthesis is clearly superior, say so

---

When NOT to Use

• Simple decisions with obvious answers (overkill)
• Time-critical situations (too slow)
• Creative tasks where multiple valid outputs are fine
• Problems where expert consensus already exists

Principle: Adversarial Validation is for decisions where quality matters more than speed.

---

Related Workflows:

• parallelAnalysis.md - For stress-testing existing arguments
• Tree-of-thought.md (PAI) - For exploring branches before committing

Last Updated: 2025-11-27

Red Team Parallel Analysis Workflow

Voice Notification

curl -s -X POST http://localhost:31337/notify \
  -H "Content-Type: application/json" \
  -d '{"message": "Running the ParallelAnalysis workflow in the RedTeam skill to red team arguments"}' \
  > /dev/null 2>&1 &

Running the ParallelAnalysis workflow in the RedTeam skill to red team arguments...

Overview

Military-grade adversarial analysis using parallel agent deployment. Breaks arguments into atomic components, attacks from 32 different expert perspectives simultaneously, synthesizes findings, and produces the ultimate counter-argument.

Key Philosophy: This is NOT about nitpicking or being contrarian. It's about finding the fundamental flaw in an argument's logic - the assumption that, if challenged, causes the entire structure to collapse.

---

The Five Phases

PHASE 1: DECOMPOSITION

Break the argument into 24 atomic claims using storyexplanation methodology.

PHASE 2: PARALLEL ANALYSIS

Launch 32 specialized agents (8 each: engineers, architects, pentesters, interns) with unique personalities to examine BOTH strengths AND weaknesses from their perspective.

PHASE 3: SYNTHESIS

Collect all 32 analyses and identify convergent insights (both supporting and opposing).

PHASE 4: STEELMAN

Produce an 8-point story explanation (12-16 words each) representing the STRONGEST possible version of the original argument.

PHASE 5: COUNTER-ARGUMENT

Produce an 8-point story explanation (12-16 words each) representing the strongest possible rebuttal.

---

PHASE 1: Decomposition Protocol

Step 1.0: First Principles Deconstruction (NEW)

Before traditional decomposition, invoke FirstPrinciples/Deconstruct:

→ FirstPrinciples/Deconstruct on the argument

This surfaces:

• What the argument is actually made of (constituent parts)
• The fundamental truths vs. assumed truths
• The gap between stated components and actual components

Output feeds into Step 1.1.

Step 1.1: Extract the Core Argument

Read the content and identify:

• The central thesis (one sentence)
• The key supporting claims (numbered list)
• The implicit assumptions (what must be true for this to work)
• The logical chain (A → B → C → conclusion)

Step 1.2: Break Into 24 Atomic Pieces

Using storyexplanation methodology, decompose the argument into exactly 24 discrete claims:

CLAIM 1: [First atomic claim from the argument]
CLAIM 2: [Second atomic claim]
...
CLAIM 24: [Twenty-fourth atomic claim]

Each claim should be:

• Self-contained (understandable without other claims)
• Specific (not vague or general)
• Attackable (a competent critic could challenge it)

---

PHASE 2: Parallel Agent Deployment

Launch Protocol

Deploy 32 agents in a SINGLE message with multiple Task tool calls. Each agent receives: 1. The full original argument 2. The 24-claim decomposition 3. Their specific personality and attack angle 4. Instructions to return a focused critique

Agent Roster: 8 Engineers

Each focuses on technical and logical rigor:

Agent Roster: 8 Architects

Each focuses on structural and systemic issues:

Agent Roster: 8 Pentesters

Each focuses on adversarial and security thinking:

Agent Roster: 8 Interns

Each brings fresh eyes and unconventional perspectives:

Agent Prompt Template

Each agent receives this prompt (customized with their personality):

# BALANCED ANALYSIS - [AGENT ID]: [PERSONALITY NAME]

You are [PERSONALITY DESCRIPTION]. Your perspective is: "[PERSPECTIVE]"

## THE ARGUMENT TO ANALYZE:
[Full original argument]

## DECOMPOSED INTO 24 CLAIMS:
[24-claim breakdown]

## YOUR MISSION:
Using your specific personality and perspective, provide an INDEPENDENT BALANCED ANALYSIS examining BOTH the strengths AND weaknesses of this argument.

### PART A - STRENGTHS (What's RIGHT about this argument):
1. Which claim(s) are strongest? (cite claim numbers)
2. What evidence or logic supports them? (2-3 sentences)
3. Why should we take this seriously? (1 sentence)

### PART B - WEAKNESSES (What's WRONG about this argument):
1. Which claim(s) are weakest? (cite claim numbers)
2. What's the flaw? (2-3 sentences)
3. Why is this a problem? (1 sentence)

## OUTPUT FORMAT:
Return exactly this structure:

**[AGENT ID] ANALYSIS:**

**Strongest Point FOR the Argument:** [Claim #X]
[2-3 sentences on why this is valid/compelling]
Take seriously because: [1 sentence]

**Strongest Point AGAINST the Argument:** [Claim #Y]
[2-3 sentences on the flaw]
Problematic because: [1 sentence]

**Overall Assessment:** [One sentence - your independent verdict on the argument's merit]

Be intellectually honest. Find REAL strengths, not strawmen to knock down.
Find REAL weaknesses, not nitpicks.
Your job is balanced analysis from your unique perspective.

---

PHASE 3: Synthesis Protocol

Step 3.1: Collect All 32 Analyses

Wait for all agents to complete. Compile their outputs.

Step 3.2: Identify Convergent STRENGTHS

Look for supporting points that multiple agents independently identified:

• If 5+ agents validated the same point → STRONG FOUNDATION
• If 3-4 agents validated the same point → NOTABLE STRENGTH
• If 1-2 agents found a unique strength → INTERESTING SUPPORT

Step 3.3: Identify Convergent WEAKNESSES

Look for critiques that multiple agents independently identified:

• If 5+ agents hit the same point → CRITICAL WEAKNESS
• If 3-4 agents hit the same point → SIGNIFICANT WEAKNESS
• If 1-2 agents hit a unique point → NOTABLE INSIGHT

Step 3.4: Categorize Insights

Group by type: STRENGTHS: 1. Valid Evidence - Claims with solid support 2. Sound Logic - Reasoning that follows 3. Real Problem Identified - Genuine issue being addressed 4. Historical Support - Precedents that validate

WEAKNESSES: 1. Logical Fallacies - Flawed reasoning structure 2. Missing Evidence - Claims without support 3. Hidden Assumptions - Unstated premises that may be false 4. Counterexamples - Cases where the argument fails 5. Precedent Contradictions - History says otherwise 6. Second-Order Effects - Consequences the argument ignores

Step 3.5: Identify Core Thesis Validity

Determine: Is the core thesis fundamentally sound with flawed execution, or fundamentally flawed despite good intentions?

---

PHASE 4: Steelman Protocol

Purpose

Before attacking, construct the STRONGEST possible version of the argument. This ensures intellectual honesty and prevents strawmanning.

Step 4.1: Identify Best Evidence

From the synthesis, what are the strongest supporting points?

Step 4.2: Reconstruct Optimal Argument

If the author had made their case PERFECTLY, what would it look like?

Step 4.3: Output Format (8 points, 12-16 words each)

# STEELMAN

**The Position (Best Version):** [One sentence - the strongest formulation]

**The Strongest Case FOR This Argument:**

1. [12-16 words - the most compelling opening point]

2. [12-16 words - strong supporting evidence]

3. [12-16 words - historical precedent or analogy that supports]

4. [12-16 words - valid concern being addressed]

5. [12-16 words - what the critics get wrong]

6. [12-16 words - the real risk if ignored]

7. [12-16 words - why smart people believe this]

8. [12-16 words - the strongest single reason to take this seriously]

**Validity Assessment:** [One sentence on the legitimate core concern]

---

PHASE 5: Counter-Argument

First Principles Analysis

Before finalizing the counter-argument, invoke FirstPrinciples/Challenge:

→ FirstPrinciples/Challenge on all stated constraints and assumptions

This classifies every constraint as:

• HARD (physics/reality - cannot attack)
• SOFT (policy/choice - can be challenged)
• ASSUMPTION (unvalidated - prime attack target)

The most devastating critiques target assumptions classified as HARD that are actually SOFT.

Then apply these additional checks:

Step 1: Identify the argument's core claim type:

• Causal ("X causes Y")
• Comparative ("X is better/worse than Y")
• Categorical ("X belongs to category Y")
• Predictive ("X will lead to Y")
• Normative ("We should/shouldn't do X")

Step 2: Surface hidden assumptions (from FirstPrinciples/Challenge output):

• What must be true for this argument to work?
• What does the author take for granted?
• What evidence is assumed but not provided?
• Which "constraints" are actually choices?

Step 3: Check for historical precedent:

• Has this exact argument been made before in another domain?
• What was the outcome when people accepted it?
• What was the outcome when people rejected it?

Step 4: Test logical validity:

• Does the conclusion actually follow from the premises?
• Are there logical fallacies present?
• Is correlation being presented as causation?

Step 5: Ensure counter-argument defeats the STEELMAN:

• Does it address the STRONGEST version of the argument?
• Or does it only defeat a weaker strawman?
• Would a proponent say "that's not what I meant"?

Output Format: 8-Point Story Explanation

The final output must be exactly 8 numbered points, each 12-16 words:

# RED TEAM VERDICT

**The Position:** [One sentence summary of what was red-teamed]

**The Counter-Argument:**

1. [First key point - 12-16 words - establishes the fundamental flaw]

2. [Second point - 12-16 words - develops the core weakness]

3. [Third point - 12-16 words - provides historical precedent or analogy]

4. [Fourth point - 12-16 words - addresses the hidden assumption]

5. [Fifth point - 12-16 words - shows the counterexample or exception]

6. [Sixth point - 12-16 words - reveals what's conveniently ignored]

7. [Seventh point - 12-16 words - exposes the second-order effects]

8. [Eighth point - 12-16 words - delivers the knockout conclusion]

**Assessment:** [One sentence on the argument's fundamental soundness after analysis]

Quality Criteria for Final Output

Each point should:

• Be self-contained and comprehensible alone
• Attack a real weakness, not a strawman
• Use plain language, not jargon
• Follow logically from previous points
• Build toward the devastating conclusion

The 8-point sequence should:

• Tell a coherent counter-narrative
• Escalate in impact
• End with the strongest possible objection
• Make the reader say "I hadn't thought of that"

---

Execution Checklist

□ PHASE 1: Decomposition
  □ Invoke FirstPrinciples/Deconstruct on the argument (NEW)
  □ Read and understand the full argument
  □ Extract central thesis
  □ Identify supporting claims
  □ Surface hidden assumptions
  □ Break into exactly 24 atomic claims

□ PHASE 2: Parallel Analysis
  □ Prepare 32 agent prompts with unique personalities
  □ Launch ALL 32 agents in a SINGLE message (parallel)
  □ Each agent: engineer, architect, pentester, or intern type
  □ Each agent examines BOTH strengths AND weaknesses
  □ Wait for all agents to complete

□ PHASE 3: Synthesis
  □ Collect all 32 analyses
  □ Identify convergent STRENGTHS (5+ agents = strong foundation)
  □ Identify convergent WEAKNESSES (5+ agents = critical weakness)
  □ Categorize by type
  □ Determine core thesis validity

□ PHASE 4: Steelman
  □ Identify best supporting evidence from synthesis
  □ Reconstruct optimal version of the argument
  □ Draft 8-point steelman explanation
  □ Each point: 12-16 words
  □ Present the STRONGEST case FOR the argument

□ PHASE 5: Counter-Argument
  □ Invoke FirstPrinciples/Challenge on all constraints (NEW)
  □ Classify constraints as HARD/SOFT/ASSUMPTION
  □ Apply first-principles analysis (claim type, assumptions, precedent, validity)
  □ Draft 8-point counter-argument
  □ Each point: 12-16 words
  □ Verify logical flow and escalation
  □ End with knockout conclusion that addresses the steelman

---

Example: First Principles Pattern Recognition

Argument: "We should delay this product launch by six months to add more features."

First Principles Analysis:

• Claim type: Normative ("we should do X")
• Hidden assumptions: More features = more success; competitors won't act; market timing is flexible
• Historical precedent: Many products failed by over-engineering; many succeeded by shipping MVP fast
• Logical validity: Doesn't follow that delay improves outcome without evidence on feature-value tradeoff

Steelman (8 points, 12-16 words each):

1. Shipping incomplete products damages brand reputation in ways that take years to recover from. 2. Customer acquisition cost is wasted if users churn due to missing core functionality they expected. 3. Apple's delayed product releases consistently outperform rushed competitors on customer satisfaction metrics. 4. The features we're adding directly address the top three complaints from our beta user research. 5. Critics ignore that our competitors have those features—parity is table stakes, not gold-plating. 6. Six months of development costs less than one year of customer support for a broken product. 7. Engineering teams lose motivation when forced to ship work they know is incomplete and buggy. 8. The real risk isn't delay—it's launching something we'll have to apologize for publicly later.

Counter-Argument (8 points, 12-16 words each):

1. This assumes we know which features matter—but only real users reveal what actually drives value. 2. Every month of delay is a month competitors can capture market share we'll never recover. 3. Amazon, Google, and Facebook all shipped embarrassingly incomplete v1 products that dominated their markets. 4. The argument conflates "more features" with "better product"—complexity often destroys rather than creates value. 5. Six months assumes accurate estimation—software projects routinely take 2-3x longer than predicted anyway. 6. We can add features after launch; we cannot add back the time lost to a delayed launch. 7. Customer feedback on a live product is worth more than six months of internal speculation. 8. The fundamental error: treating product development as a single bet rather than an iterative learning process.

---

Integration Notes

This workflow requires:

• Task tool for launching parallel agents
• Ability to launch 32+ agents simultaneously
• Synthesis capability to process multiple agent outputs
• FirstPrinciples skill for Deconstruct (Phase 1) and Challenge (Phase 5)

Pairs well with:

• FirstPrinciples/Deconstruct - breaks argument into fundamental parts (Phase 1)
• FirstPrinciples/Challenge - classifies constraints as HARD/SOFT/ASSUMPTION (Phase 5)
• storyexplanation skill for initial decomposition
• extractalpha for finding highest-signal critiques
• research skill for finding counterexamples and precedents

Time estimate:

• Phase 1: 2-3 minutes (decomposition)
• Phase 2: 3-5 minutes (parallel execution)
• Phase 3: 2-3 minutes (synthesis)
• Phase 4: 2-3 minutes (final output)
• Total: ~10-15 minutes for comprehensive red team

---

Last Updated: 2025-11-24