Claude-Code-Workflow/.codex/prompts/quick-plan-with-file.md

description, argument-hint

description	argument-hint
Multi-agent rapid planning with minimal documentation, conflict resolution, and actionable synthesis. Lightweight planning from raw task, brainstorm, or analysis artifacts	TOPIC="<planning topic or task>" [--from=brainstorm|analysis|task|raw] [--perspectives=arch,impl,risk,decision] [--auto] [--verbose]

Codex Quick-Plan-With-File Prompt

Overview

Multi-agent rapid planning workflow with minimal documentation overhead. Coordinates parallel agent analysis (architecture, implementation, validation, decision), synthesizes conflicting perspectives into actionable decisions, and generates an implementation-ready plan.

Core workflow: Parse Input → Parallel Analysis → Conflict Resolution → Plan Synthesis → Output

Key features:

• Format Agnostic: Consumes brainstorm conclusions, analysis recommendations, quick tasks, or raw descriptions
• Minimal Docs: Single plan.md (no lengthy timeline documentation)
• Parallel Multi-Agent: 4 concurrent perspectives for rapid analysis
• Conflict Resolution: Automatic conflict detection and synthesis
• Actionable Output: Direct task breakdown ready for execution

Target Planning

$TOPIC

• --from: Input source type (brainstorm | analysis | task | raw) - auto-detected if omitted
• --perspectives: Which perspectives to use (arch, impl, risk, decision) - all by default
• --auto: Auto-confirm decisions, minimal user prompts
• --verbose: Verbose output with all reasoning

Execution Process

Phase 1: Input Validation & Loading
   ├─ Parse input: topic | artifact reference
   ├─ Load artifact if referenced (synthesis.json | conclusions.json)
   ├─ Extract constraints and key requirements
   └─ Initialize session folder

Phase 2: Parallel Multi-Agent Analysis (concurrent)
   ├─ Agent 1 (Architecture): Design decomposition, patterns, scalability
   ├─ Agent 2 (Implementation): Tech stack, feasibility, effort estimates
   ├─ Agent 3 (Validation): Risk matrix, testing strategy, monitoring
   ├─ Agent 4 (Decision): Recommendations, tradeoffs, execution strategy
   └─ Aggregate findings into perspectives.json

Phase 3: Conflict Detection & Resolution
   ├─ Detect: effort conflicts, architecture conflicts, risk conflicts
   ├─ Analyze rationale for each conflict
   ├─ Synthesis via arbitration: generate unified recommendation
   ├─ Document conflicts and resolutions
   └─ Update plan.md

Phase 4: Plan Synthesis
   ├─ Consolidate all insights
   ├─ Generate task breakdown (5-8 major tasks)
   ├─ Create execution strategy and dependencies
   ├─ Document assumptions and risks
   └─ Output plan.md + synthesis.json

Output:
   ├─ .workflow/.planning/{sessionId}/plan.md (minimal, actionable)
   ├─ .workflow/.planning/{sessionId}/perspectives.json (agent findings)
   ├─ .workflow/.planning/{sessionId}/conflicts.json (decision points)
   └─ .workflow/.planning/{sessionId}/synthesis.json (task breakdown for execution)

Implementation Details

Phase 1: Session Setup & Input Loading

const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()

// Parse input
const planSlug = "$TOPIC".toLowerCase()
  .replace(/[^a-z0-9\u4e00-\u9fa5]+/g, '-')
  .substring(0, 30)
const sessionId = `PLAN-${planSlug}-${getUtc8ISOString().substring(0, 10)}`
const sessionFolder = `.workflow/.planning/${sessionId}`

// Detect input type
let artifact = null
if ($TOPIC.startsWith('BS-') || "$TOPIC".includes('brainstorm')) {
  artifact = loadBrainstormArtifact($TOPIC)
} else if ($TOPIC.startsWith('ANL-') || "$TOPIC".includes('analysis')) {
  artifact = loadAnalysisArtifact($TOPIC)
}

bash(`mkdir -p ${sessionFolder}`)

Phase 2: Parallel Multi-Agent Analysis

Run 4 agents in parallel using ccw cli:

// Launch all 4 agents concurrently with Bash run_in_background
const agentPromises = []

// Agent 1 - Architecture (Gemini)
agentPromises.push(
  Bash({
    command: `ccw cli -p "
PURPOSE: Architecture & high-level design for '${planningTopic}'
Success: Clear component decomposition and architectural approach

TASK:
• Decompose problem into major components/modules
• Identify architectural patterns and integration points
• Design component interfaces and data models
• Assess scalability and maintainability implications
• Propose architectural approach with rationale

MODE: analysis

CONTEXT: @**/*
${artifact ? \`| Source artifact: \${artifact.type}\` : ''}

EXPECTED:
- Component decomposition (list with responsibilities)
- Module interfaces and contracts
- Data flow between components
- Architectural patterns applied (e.g., MVC, Event-Driven, etc.)
- Scalability assessment (1-5 rating with rationale)
- Architectural risks identified

CONSTRAINTS: Focus on long-term maintainability and extensibility
" --tool gemini --mode analysis`,
    run_in_background: true
  })
)

// Agent 2 - Implementation (Codex)
agentPromises.push(
  Bash({
    command: \`ccw cli -p "
PURPOSE: Implementation approach & technical feasibility for '\${planningTopic}'
Success: Concrete implementation strategy with realistic estimates

TASK:
• Evaluate technical feasibility of proposed approach
• Identify required technologies and dependencies
• Estimate effort: analysis/design/coding/testing/deployment
• Suggest implementation phases and milestones
• Highlight technical blockers and challenges

MODE: analysis

CONTEXT: @**/*
\${artifact ? \`| Source artifact: \${artifact.type}\` : ''}

EXPECTED:
- Technology stack recommendation (languages, frameworks, tools)
- Implementation complexity: high|medium|low (with justification)
- Effort breakdown (hours or complexity: analysis, design, coding, testing, deployment)
- Key technical decisions with tradeoffs explained
- Potential blockers and mitigation strategies
- Suggested implementation phases with sequencing
- Reusable components or libraries identified

CONSTRAINTS: Realistic with current tech stack
" --tool codex --mode analysis\`,
    run_in_background: true
  })
)

// Agent 3 - Validation & Risk (Claude)
agentPromises.push(
  Bash({
    command: \`ccw cli -p "
PURPOSE: Risk analysis and validation strategy for '\${planningTopic}'
Success: Comprehensive risk matrix with testing and deployment strategy

TASK:
• Identify technical risks and failure scenarios
• Assess timeline and resource risks
• Define validation/testing strategy (unit, integration, e2e, performance)
• Suggest monitoring and observability requirements
• Propose deployment strategy and rollback plan

MODE: analysis

CONTEXT: @**/*
\${artifact ? \`| Source artifact: \${artifact.type}\` : ''}

EXPECTED:
- Risk matrix (likelihood × impact, each 1-5)
- Top 3 technical risks with mitigation approaches
- Top 3 timeline/resource risks with mitigation
- Testing strategy (what to test, how, when, acceptance criteria)
- Deployment strategy (staged rollout, blue-green, canary, etc.)
- Rollback plan and recovery procedures
- Monitoring/observability requirements (metrics, logs, alerts)
- Overall risk rating: low|medium|high (with confidence)

CONSTRAINTS: Be realistic, not pessimistic
" --tool claude --mode analysis\`,
    run_in_background: true
  })
)

// Agent 4 - Strategic Decision (Gemini)
agentPromises.push(
  Bash({
    command: \`ccw cli -p "
PURPOSE: Strategic decisions and execution recommendations for '\${planningTopic}'
Success: Clear recommended approach with tradeoff analysis

TASK:
• Synthesize all perspectives into strategic recommendations
• Identify 2-3 critical decision points with recommended choices
• Clearly outline key tradeoffs (speed vs quality, scope vs timeline, risk vs cost)
• Propose go/no-go decision criteria and success metrics
• Suggest execution strategy and resource sequencing

MODE: analysis

CONTEXT: @**/*
\${artifact ? \`| Source artifact: \${artifact.type}\` : ''}

EXPECTED:
- Primary recommendation with strong rationale (1-2 paragraphs)
- Alternative approaches with pros/cons (2-3 alternatives)
- 2-3 critical decision points:
  - What decision needs to be made
  - Trade-offs for each option
  - Recommended choice and why
- Key trade-offs explained (what we're optimizing for: speed/quality/risk/cost)
- Success metrics and go/no-go criteria
- Resource requirements and critical path items
- Suggested execution sequencing and phases

CONSTRAINTS: Focus on actionable decisions, provide clear rationale
" --tool gemini --mode analysis\`,
    run_in_background: true
  })
)

// Wait for all agents to complete
const [archResult, implResult, riskResult, decisionResult] = await Promise.all(agentPromises)

// Parse and extract findings from each agent result
const architecture = parseArchitectureResult(archResult)
const implementation = parseImplementationResult(implResult)
const validation = parseValidationResult(riskResult)
const recommendation = parseDecisionResult(decisionResult)

Agent Focus Areas:

Agent	Perspective	Focus Areas
Gemini (Design)	Architecture patterns	Components, interfaces, scalability, patterns
Codex (Build)	Implementation reality	Tech stack, complexity, effort, blockers
Claude (Validate)	Risk & testing	Risk matrix, testing strategy, deployment, monitoring
Gemini (Decide)	Strategic synthesis	Recommendations, trade-offs, critical decisions

Phase 3: Parse & Aggregate Perspectives

const perspectives = {
  session_id: sessionId,
  topic: "$TOPIC",
  timestamp: getUtc8ISOString(),

  architecture: {
    components: [...],
    patterns: [...],
    scalability_rating: 3,
    risks: [...]
  },

  implementation: {
    technology_stack: [...],
    complexity: "medium",
    effort_breakdown: { analysis: 2, design: 3, coding: 8, testing: 4 },
    blockers: [...]
  },

  validation: {
    risk_matrix: [...],
    top_risks: [{ title, impact, mitigation }, ...],
    testing_strategy: "...",
    monitoring: [...]
  },

  recommendation: {
    primary_approach: "...",
    alternatives: [...],
    critical_decisions: [...],
    tradeoffs: [...]
  }
}

Write(`${sessionFolder}/perspectives.json`, JSON.stringify(perspectives, null, 2))

Phase 4: Conflict Detection

Detect conflicts:

• Effort variance: Are estimates consistent?
• Risk disagreement: Do arch and validation agree on risks?
• Scope confusion: Are recommendations aligned?
• Architecture mismatch: Do design and implementation agree?

For each conflict: document it, then run synthesis arbitration.

Phase 5: Generate Plan

# Quick Planning Session

**Session ID**: ${sessionId}
**Topic**: $TOPIC
**Created**: ${timestamp}

---

## Executive Summary

${synthesis.executive_summary}

**Complexity**: ${synthesis.complexity_level}
**Estimated Effort**: ${formatEffort(synthesis.effort_breakdown)}
**Optimization Focus**: ${synthesis.optimization_focus}

---

## Architecture

**Primary Pattern**: ${synthesis.architecture_approach}

**Key Components**:
${synthesis.key_components.map((c, i) => `${i+1}. ${c.name}: ${c.responsibility}`).join('\n')}

---

## Implementation Strategy

**Technology Stack**:
${synthesis.technology_stack.map(t => `- ${t}`).join('\n')}

**Phases**:
${synthesis.phases.map((p, i) => `${i+1}. ${p.name} (${p.effort})`).join('\n')}

---

## Risk Assessment

**Overall Risk**: ${synthesis.overall_risk_level}

**Top 3 Risks**:
${synthesis.top_risks.map((r, i) => `${i+1}. **${r.title}** (Impact: ${r.impact})\n   Mitigation: ${r.mitigation}`).join('\n\n')}

---

## Task Breakdown (Ready for Execution)

${synthesis.tasks.map((task, i) => `
${i+1}. **${task.id}: ${task.title}** (Effort: ${task.effort})
   ${task.description}
   Dependencies: ${task.dependencies.join(', ') || 'none'}
`).join('\n')}

---

## Next Steps

**Execute with**:
\`\`\`
/workflow:unified-execute-with-file -p ${sessionFolder}/synthesis.json
\`\`\`

**Detailed planning if needed**:
\`\`\`
/workflow:plan "Based on: $TOPIC"
\`\`\`

Session Folder Structure

.workflow/.planning/{sessionId}/
├── plan.md              # Minimal, actionable
├── perspectives.json    # Agent findings
├── conflicts.json       # Conflicts & resolutions (if any)
└── synthesis.json       # Task breakdown for execution

Multi-Agent Coordination

Agent	Perspective	Tools	Output
Gemini (Design)	Architecture patterns	Design thinking, cross-domain	Components, patterns, scalability
Codex (Build)	Implementation reality	Tech stack evaluation	Stack, effort, feasibility
Claude (Validate)	Risk & testing	Risk assessment, QA	Risks, testing strategy
Gemini (Decide)	Strategic synthesis	Decision analysis	Recommendations, tradeoffs

Error Handling

Situation	Action
Agents conflict	Arbitration agent synthesizes recommendation
Missing blockers	Continue with available context, note gaps
Unclear input	Ask for clarification on planning focus
Estimate too high	Suggest MVP approach or phasing

Integration Flow

Raw Task / Brainstorm / Analysis
         │
         ▼
quick-plan-with-file (5-10 min)
         │
         ├─ plan.md
         ├─ perspectives.json
         └─ synthesis.json
         │
         ▼
unified-execute-with-file
         │
         ▼
Implementation

Usage Patterns

Pattern 1: Quick planning from task

TOPIC="实现实时通知系统" --auto
→ Creates actionable plan in ~5 minutes

Pattern 2: Convert brainstorm to execution plan

TOPIC="BS-notifications-2025-01-28" --from=brainstorm
→ Reads synthesis.json from brainstorm
→ Generates implementation plan

Pattern 3: From analysis to plan

TOPIC="ANL-auth-2025-01-28" --from=analysis
→ Converts conclusions.json to executable plan

---

Now execute quick-plan-with-file for topic: $TOPIC