Senior Planning Team Workflow

Senior Planning Team Workflow

You orchestrate a team of senior engineers who comprehensively interview the user to create a detailed Engineering Specification with complete TDD test plans.

When to Use This Skill

• User says "plan this feature"
• User requests "create a spec"
• User wants "detailed design"
• At start of plan mode for complex features

Team Members

Your senior engineering team consists of:

1. Code Rule Reader: Discovers project coding standards
2. Task Classifier (NEW): Analyzes feature type and determines optimal interview plan
3. Tech Interviewer: Technical architecture & system design (mandatory)
4. UX Interviewer: User experience & interface design (conditional)
5. Security Interviewer: Security, compliance, & data protection (mandatory)
6. TDD Test Engineer: Test strategy & comprehensive test cases (mandatory)
7. Test Coverage Verifier: Validates test completeness (mandatory)
8. Performance Interviewer: Scalability & performance optimization (conditional)
9. Integration Interviewer: External dependencies & deployment (conditional)
10. Spec Writer: Synthesizes all findings into SPEC.md (mandatory)
11. Implementation Planner: Converts SPEC.md into explicit execution plan for cheaper models (mandatory)

Workflow Overview (65-105 minutes, optimized based on task type)

Discovery (5min) → Coding Standards (parallel, 5min)
    ↓
Task Classification (5min) ← NEW: Determines which interviews to run
    ↓
Technical Interview (15-20min) [MANDATORY]
    ↓
UX Interview (10-15min) [CONDITIONAL - skipped for backend-only]
    ↓
Security Interview (5-10min) [MANDATORY - brief or full]
    ↓
TDD Test Engineering (20-30min) [MANDATORY]
    ↓
Test Coverage Verification (10-15min) [MANDATORY]
    ↓
Performance Interview (10min) [CONDITIONAL - skipped if no scale concerns]
    ↓
Integration Interview (10min) [CONDITIONAL - skipped if no external deps]
    ↓
Spec Synthesis (10min) [MANDATORY]
    ↓
SPEC.md Created
    ↓
Implementation Planning (10-15min) [MANDATORY]
    ↓
IMPLEMENTATION_PLAN.md Created ✓

Time savings: 20-40 min for clearly typed features (e.g., pure backend skips UX, perf)

Phase 0: Setup

Create todo list to track progress:

TodoWrite({
  todos: [
    {content: "Discovery & codebase understanding", status: "in_progress", activeForm: "Understanding codebase and requirements"},
    {content: "Read project coding standards", status: "pending", activeForm: "Reading coding standards"},
    {content: "Classify task and plan interviews", status: "pending", activeForm: "Classifying task type and planning interviews"},
    {content: "Technical architecture interview", status: "pending", activeForm: "Conducting technical interview"},
    {content: "UX interview", status: "pending", activeForm: "Conducting UX interview"},
    {content: "Security interview", status: "pending", activeForm: "Conducting security interview"},
    {content: "TDD test specification", status: "pending", activeForm: "Creating TDD test specifications"},
    {content: "Test coverage verification", status: "pending", activeForm: "Verifying test coverage"},
    {content: "Performance interview", status: "pending", activeForm: "Conducting performance interview"},
    {content: "Integration interview", status: "pending", activeForm: "Conducting integration interview"},
    {content: "Synthesize SPEC.md", status: "pending", activeForm: "Synthesizing specification"},
    {content: "Create implementation plan", status: "pending", activeForm: "Creating implementation plan"},
    {content: "Review and deliver", status: "pending", activeForm: "Reviewing final specification"}
  ]
});

**Note**: After Phase 1.8 (task classification), this todo list will be updated to remove skipped agents based on the execution plan.

Phase 1: Discovery & Codebase Understanding (5 min)

Goal: Understand what's being built and existing codebase context.

Actions:

1. Understand user request:

   • What feature/problem are we solving?
   • Why is it needed?
   • What does success look like?

2. Explore codebase (if new feature):

   • Use Glob to find similar features
   • Use Grep to search for related code
   • Read key architecture files

3. Summarize:

   ## Discovery Summary
   
   **Feature Request**: [User's description]
   **Problem**: [What problem this solves]
   **Success Criteria**: [What success looks like]
   **Similar Features**: [Existing patterns found]
   **Key Files**: [Relevant architecture files]
   

Mark todo complete, move to next: "Read project coding standards"

Phase 1.5: Project Coding Standards (Parallel, 5 min)

Goal: Discover project-specific coding conventions before interviews.

Actions: Launch code-rule-reader agent:

Task(code-rule-reader): "Discover and document project coding standards.
Search for AGENTS.md, CLAUDE.md, and convention files in:
- Root directory
- .claude/ directory
- src/ and feature directories
- docs/ directory

Return comprehensive guide on:
- Code organization and file naming
- Architecture patterns to follow
- Language/framework conventions
- Testing standards
- Database conventions
- API conventions
- Style guidelines

Feature context: [brief feature description]"

Wait for completion, then mark todo complete.

Result: Coding standards guide that all subsequent specifications will follow.

Phase 1.8: Task Classification & Execution Planning (5 min)

Goal: Determine which interview agents are necessary based on feature type and context.

Actions:

1. Mark todo as in_progress: "Classifying task type and planning interviews"

2. Launch task-classifier agent:

   Task(task-classifier): "Analyze feature requirements and determine optimal interview plan.
   
   Feature description: [Original user request]
   
   Discovery context:
   - Discovery summary: [Summary from Phase 1]
   - Coding standards: [Standards from Phase 1.5]
   - Codebase patterns: [Patterns found during discovery]
   
   Analyze the feature to determine:
   1. Task type (Backend Only / Frontend Only / Full-Stack / Infrastructure)
   2. Which interview agents must run (with reasoning and focus areas)
   3. Which agents can be skipped (with justification)
   4. Optimized execution plan with time estimates
   
   Output comprehensive execution plan with classification analysis."
   

3. Wait for classification complete

4. Review classification output: The agent will provide structured execution plan

5. Store classification for reference: Will be passed to subsequent agents

6. Validate classification:

   • Task type is one of: Backend Only / Frontend Only / Full-Stack / Infrastructure
   • At least 5 mandatory agents marked "to run"
   • Security agent is never completely skipped
   • All skip decisions have clear reasoning

   If validation fails: Fall back to running all agents (current full behavior)

7. Update TodoWrite to reflect actual agents being run:

   • Remove skipped agents from todo list
   • Update time estimates based on classification
   • Keep all mandatory agents (tech, TDD, coverage, spec, implementation-planner)

8. Mark todo complete, move to first interview in execution plan

Output: Execution plan stored, todo list updated, ready for conditional interview execution.

Fallback Strategy: If classification fails or produces invalid output, log error to user ("Classification couldn't complete, running full interview suite") and proceed with all agents to ensure comprehensive coverage.

Phase 2: Technical Architecture Interview (15-20 min) [MANDATORY]

Goal: Deep understanding of technical design.

Actions:

1. Mark todo as in_progress: "Conducting technical interview"

2. Launch tech-interviewer agent:

   Task(tech-interviewer): "Conduct comprehensive technical architecture interview for [feature name].
   
   Context from discovery:
   - [Discovery summary]
   - [Coding standards summary]
   
   Ask in-depth questions about:
   - System architecture and component design
   - Data models and database schema
   - API contracts and interfaces
   - Technology stack choices
   - Implementation approach
   
   Continue interviewing until you have complete technical understanding.
   Produce structured technical architecture summary."
   

3. Wait for agent completion

4. Review output: Read technical interview summary

5. Mark todo complete, move to: "UX interview" (check execution plan first)

Phase 3: UX Interview (10-15 min) [CONDITIONAL]

Goal: Comprehensive user experience understanding.

Check Execution Plan: Is ux-interviewer in the "To Run" list from Phase 1.8 classification?

• If YES (frontend or full-stack feature): Proceed with UX interview below
• If NO (backend-only or infrastructure): Skip to Phase 4 (Security Interview). The classification plan will provide brief UX guidance for spec-writer.

Actions (if running):

1. Mark todo as in_progress: "Conducting UX interview"

2. Launch ux-interviewer agent with classification context:

   Task(ux-interviewer): "Conduct comprehensive UX interview for [feature name].
   
   Context:
   - Technical architecture: [Brief summary of technical decisions]
   - Coding standards: [Relevant UX/component standards]
   - Classification reasoning: [Why UX interview was selected from Phase 1.8]
   - Focus areas: [Specific UX areas to emphasize from classification]
   
   Ask detailed questions about:
   - User workflows and journeys
   - Interface design and components
   - Accessibility requirements
   - Error handling and edge states
   - Responsive design
   
   Continue until UX is fully specified.
   Produce structured UX summary."
   

3. Wait for completion

4. Review UX summary

5. Mark todo complete, move to: "Security interview"

Phase 4: Security Interview (5-10 min) [MANDATORY - may be brief]

Goal: Security and compliance clarity.

Note: Security interview always runs (never skipped) but may be brief (5 min) for low-risk features or full (10 min) for features handling sensitive data, as determined by Phase 1.8 classification.

Actions:

1. Mark todo as in_progress: "Conducting security interview"

2. Launch security-interviewer agent:

   Task(security-interviewer): "Conduct security and compliance interview for [feature name].
   
   Context:
   - Technical: [What data is handled, what APIs exposed]
   - UX: [What user actions are possible]
   
   Ask about:
   - Authentication and authorization
   - Data protection and encryption
   - Compliance requirements (GDPR, SOC2, etc.)
   - Security boundaries and input validation
   - Audit logging
   - Threat modeling
   
   Produce structured security summary."
   

3. Wait for completion

4. Review security summary

5. Mark todo complete, move to: "TDD test specification"

Phase 5: TDD Test Specification (20-30 min)

Goal: Create comprehensive test cases before implementation (TDD approach).

Actions:

1. Mark todo as in_progress: "Creating TDD test specifications"

2. Launch tdd-test-engineer agent:

   Task(tdd-test-engineer): "Create comprehensive TDD test specification for [feature name].
   
   Context from all interviews:
   - Technical architecture: [Components, APIs, data models]
   - UX design: [User workflows, interactions]
   - Security requirements: [What needs security testing]
   
   Create test specifications that enable RED → GREEN → REFACTOR TDD workflow.
   
   For each component:
   - Specify detailed test cases (Given/When/Then)
   - Provide example test code
   - Define mocking strategy
   - Create step-by-step TDD implementation guide
   
   Coverage goal: [Based on component criticality]
   Testing tools: [From coding standards or tech interview]
   
   Output: Complete test specification with test cases for all components."
   

3. Wait for completion

4. Review test specification

5. Mark todo complete, move to: "Test coverage verification"

Phase 6: Test Coverage Verification (10-15 min)

Goal: Verify test specifications match user intent and cover all scenarios.

Actions:

1. Mark todo as in_progress: "Verifying test coverage"

2. Launch test-coverage-verifier agent:

   Task(test-coverage-verifier): "Verify test coverage completeness for [feature name].
   
   Review the TDD test specification and validate:
   - Test cases match user's original intent
   - All functional requirements have corresponding tests
   - Edge cases and error scenarios are covered
   - Performance scenarios are tested (if critical)
   - Security scenarios are tested
   - No gaps in coverage
   
   Original user request: [User's feature description]
   Technical requirements: [From tech interview]
   UX requirements: [From UX interview]
   Security requirements: [From security interview]
   
   Use AskUserQuestion to clarify any gaps or ambiguities.
   Produce verification report with any additions/modifications needed."
   

3. Wait for completion

4. Review verification report

5. Mark todo complete, move to: "Performance interview" (check execution plan first)

Phase 7: Performance Interview (10 min) [CONDITIONAL]

Goal: Performance and scale requirements.

Check Execution Plan: Is performance-interviewer in the "To Run" list from Phase 1.8 classification?

• If YES (performance-sensitive feature): Proceed with performance interview below
• IF NO (simple CRUD, no scale concerns): Skip to Phase 8 (Integration Interview). The classification plan will provide brief performance guidance for spec-writer.

Actions (if running):

1. Mark todo as in_progress: "Conducting performance interview"

2. Launch performance-interviewer agent with classification context:

   Task(performance-interviewer): "Conduct performance and scalability interview for [feature name].
   
   Context:
   - Technical: [Architecture, data models]
   - UX: [User interactions, data displayed]
   - Security: [Security overhead considerations]
   - Classification reasoning: [Why performance interview was selected from Phase 1.8]
   - Focus areas: [Specific performance areas to emphasize from classification]
   
   Ask about:
   - Performance SLOs (latency, throughput)
   - Expected scale (users, data volume)
   - Caching strategy
   - Database optimization
   - Resource constraints
   - Monitoring requirements
   
   Produce structured performance summary."
   

3. Wait for completion

4. Review performance summary

5. Mark todo complete, move to: "Integration interview" (check execution plan first)

Phase 8: Integration Interview (10 min) [CONDITIONAL]

Goal: Integration and deployment clarity.

Check Execution Plan: Is integration-interviewer in the "To Run" list from Phase 1.8 classification?

• If YES (external dependencies or deployment complexity): Proceed with integration interview below
• IF NO (self-contained feature): Skip to Phase 9 (Spec Synthesis). The classification plan will provide brief integration guidance for spec-writer.

Actions (if running):

1. Mark todo as in_progress: "Conducting integration interview"

2. Launch integration-interviewer agent with classification context:

   Task(integration-interviewer): "Conduct integration and deployment interview for [feature name].
   
   Context from all previous interviews.
   Classification reasoning: [Why integration interview was selected from Phase 1.8]
   Focus areas: [Specific integration areas to emphasize from classification]
   
   Ask about:
   - External dependencies and third-party services
   - API integrations
   - Data migrations
   - Backward compatibility
   - Deployment strategy (rollout, feature flags)
   - Rollback procedures
   - Environment configuration
   
   Produce structured integration summary."
   

3. Wait for completion

4. Review integration summary

5. Mark todo complete, move to: "Synthesize SPEC.md"

Phase 9: Spec Synthesis (10 min)

Goal: Create comprehensive SPEC.md from all findings.

Actions:

1. Mark todo as in_progress: "Synthesizing specification"

2. Launch spec-writer agent:

   Task(spec-writer): "Synthesize all interview findings into Engineering Specification at .claude/SPEC.md
   
   Classification context from Phase 1.8:
   - Task type: [Backend Only / Frontend Only / Full-Stack / Infrastructure]
   - Agents that ran: [List of interviews conducted]
   - Agents that were skipped: [List with brief guidance for each]
   
   Input documents (only interviews that actually ran):
   - Coding standards: [Summary]
   - Task classification: [Summary from Phase 1.8]
   - Technical interview: [Path or summary] [MANDATORY - always present]
   - UX interview: [Path or summary] [CONDITIONAL - may be skipped]
   - Security interview: [Path or summary] [MANDATORY - always present, may be brief]
   - TDD test specification: [Path or summary] [MANDATORY - always present]
   - Test coverage verification: [Path or summary] [MANDATORY - always present]
   - Performance interview: [Path or summary] [CONDITIONAL - may be skipped]
   - Integration interview: [Path or summary] [CONDITIONAL - may be skipped]
   
   For skipped agent sections:
   - Include brief section based on classification guidance
   - UX (if skipped): Brief section noting "No UI component, API-only interaction"
   - Performance (if skipped): Brief section with standard expectations
   - Integration (if skipped): Brief section noting self-contained feature
   
   Create comprehensive SPEC.md with all sections:
   1. Problem Statement
   2. Solution Design
   3. API/Interface Design
   4. Data Models
   5. User Experience (detailed if UX interview ran, brief if skipped)
   6. Technical Implementation
   7. Security & Compliance
   8. Performance & Scalability (detailed if perf interview ran, brief if skipped)
   9. Test Specification (with full TDD test cases)
   10. Integration & Deployment (detailed if integration interview ran, brief if skipped)
   11. Trade-offs & Alternatives
   12. Implementation Phases
   13. Risks & Mitigations
   
   Resolve any conflicts between domains.
   Make everything specific and actionable.
   Output: .claude/SPEC.md"
   

3. Wait for SPEC.md to be created

4. Read SPEC.md to verify completeness

5. Mark todo complete, move to: "Create implementation plan"

Phase 9.5: Implementation Planning (10-15 min)

Goal: Convert high-level SPEC.md into explicit, step-by-step implementation plan for cheaper models (GLM 4.7).

Actions:

1. Mark todo as in_progress: "Creating implementation plan"

2. Launch implementation-planner agent:

   Task(implementation-planner): "Create explicit implementation plan from SPEC.md
   
   Input: `.claude/SPEC.md` (just created by spec-writer)
   
   Your mission:
   - Eliminate ALL ambiguity - convert vague requirements to explicit steps
   - Provide exact file paths for every file creation
   - Generate detailed TDD cycles (RED→GREEN→REFACTOR) with complete code
   - Create copy-paste ready boilerplate templates
   - Sequence files by dependency order
   
   Target audience: Cheaper models like GLM 4.7 that need explicit guidance
   
   Output:
   - `.claude/IMPLEMENTATION_PLAN.md` - Step-by-step execution plan
   - Enhanced sections in SPEC.md (if needed)
   
   Follow the templates:
   - `templates/decision-table.md` for decision format
   - `templates/tdd-cycle.md` for TDD cycle format
   - `templates/spec-template.md` for reference
   
   Make it so explicit that a junior developer (or GLM 4.7) can execute without asking questions."
   

3. Wait for IMPLEMENTATION_PLAN.md to be created

4. Read IMPLEMENTATION_PLAN.md to verify:

   • File sequence is dependency-ordered
   • TDD cycles have complete code (RED, GREEN, REFACTOR)
   • Boilerplate is copy-paste ready
   • All ambiguities resolved
   • Every file has explicit path

5. Mark todo complete, move to: "Review and deliver"

Phase 10: Review & Deliver (5 min)

Actions:

1. Mark todo as in_progress: "Reviewing final specification"

2. Verify SPEC.md contents:

   • All sections present
   • Technical details from tech interview
   • UX details from UX interview
   • Security requirements included
   • Complete TDD test specifications
   • Test coverage verified
   • Performance targets specified
   • Integration strategy defined

3. Present summary to user:

   # Senior Planning Complete ✓
   
   ## Comprehensive Specification + Implementation Plan Created
   
   **Locations**:
   - `.claude/SPEC.md` - Engineering Specification (design & requirements)
   - `.claude/IMPLEMENTATION_PLAN.md` - Step-by-step execution plan (for GLM 4.7 or any implementer)
   
   ## Interview Coverage
   
   - ✅ Project Coding Standards (discovered and applied)
   - ✅ Technical Architecture (system design, APIs, data models)
   - ✅ User Experience (workflows, UI, accessibility)
   - ✅ Security & Compliance (auth, data protection, audit)
   - ✅ TDD Test Specification (comprehensive test cases with RED→GREEN→REFACTOR guide)
   - ✅ Test Coverage Verification (validated against user intent)
   - ✅ Performance & Scalability (SLOs, caching, optimization)
   - ✅ Integration & Deployment (dependencies, rollout strategy)
   - ✅ Implementation Planning (explicit execution plan, zero ambiguity)
   
   ## Key Decisions Documented
   
   1. [Decision 1]: [Summary with code example]
   2. [Decision 2]: [Summary with code example]
   3. [Decision 3]: [Summary with code example]
   [... top 5 decisions - all with code examples]
   
   ## Test Strategy
   
   - **Approach**: [TDD / Pragmatic TDD / Outside-in / Inside-out]
   - **Coverage Goal**: [Percentage and scope]
   - **Test Cases**: [Number] comprehensive test cases with implementation guides
   - **Developer Guide**: Step-by-step RED→GREEN→REFACTOR workflow included
   
   ## Implementation Readiness
   
   - **SPEC.md**: Complete and actionable (design & "what/why")
   - **IMPLEMENTATION_PLAN.md**: Explicit step-by-step guide ("how" with zero ambiguity)
   - **Test Cases**: Detailed with complete code examples
   - **Coding Standards**: Documented and referenced
   - **TDD Cycles**: Every component has RED→GREEN→REFACTOR with full code
   - **Boilerplate**: Copy-paste ready templates included
   - **File Sequence**: Dependency-ordered, exact paths specified
   - **Ready for Cheap Model Execution (GLM 4.7)**: Yes ✓✓✓
   
   ## Next Steps
   
   1. **Review SPEC.md** - Read the complete specification
   2. **Start TDD Implementation** - Follow test cases in sequential order
   3. **Begin with Test Case 1** - Write failing test (RED)
   4. **Implement minimal code** - Make test pass (GREEN)
   5. **Refactor** - Clean up code while tests stay green
   6. **Repeat** - Continue through all test cases
   
   ## Time Investment
   
   - Planning time: [Actual time spent]
   - Expected implementation time: [Estimate based on complexity]
   - Quality confidence: **High** (comprehensive spec + complete test cases)
   
   ---
   
   **Ready to build** 🚀
   

4. Mark final todo complete: "Review and deliver"

5. Offer next actions:

   • "Would you like me to start implementing following the TDD test cases?"
   • "Would you like to review any specific section of SPEC.md?"
   • "Any questions or clarifications needed?"

Important Guidelines

Sequential Execution

Agents run sequentially (not parallel) because:

• Later interviews build on earlier ones
• UX interview needs technical context
• Security interview needs to know what data is handled
• TDD testing needs to know all requirements
• Test verifier needs the test spec
• Performance interview needs to know operations performed
• Integration interview needs full system understanding
• Spec writer needs all findings

Context Passing

Each agent receives:

• Original user request
• All previous interview summaries
• Coding standards (from code-rule-reader)

This builds comprehensive understanding progressively.

User Engagement

User actively participates via AskUserQuestion throughout:

• Not passive - they make decisions
• Each interviewer asks 3-4 questions per round
• Multiple rounds per interviewer
• Clarifications drive better spec

Quality Standards

Non-obvious questions: Avoid trivial, ask about edge cases, scale, trade-offs In-depth exploration: Each domain fully specified before moving on No assumptions: When unclear, ask rather than assume Complete specification: SPEC.md should be implementation-ready with comprehensive TDD test cases Test-first mentality: Tests are written in spec before implementation

Integration with Plan Mode

If in Claude Code plan mode:

• SPEC.md created as separate design document
• Plan file references SPEC.md for detailed design
• Plan file tracks implementation tasks and progress
• Both files work together

If not in plan mode:

• SPEC.md is the primary deliverable
• Contains both design AND implementation phases
• Can be used to create plan file later

Success Criteria

✅ User actively participated in interviews
✅ All domains comprehensively covered
✅ SPEC.md created with all sections
✅ Test specifications complete with TDD guides
✅ Test coverage verified against user intent
✅ No major conflicts or gaps
✅ Coding standards applied throughout
✅ User confirms spec matches their vision
✅ Implementation can begin with confidence

When NOT to Use This Skill

• Simple bug fixes (just fix it)
• Trivial changes (no planning needed)
• Well-defined tasks with clear implementation (start coding)
• Exploratory work (use exploration agents instead)
• Research questions (use research agents instead)

Estimated Duration (with task classification optimization)

With Classification (Post Phase 1.8):

• Simple backend-only features: 45-65 minutes (skips UX, perf, integration)
• Simple frontend-only features: 50-75 minutes (skips integration, may skip perf)
• Standard full-stack features: 75-90 minutes (runs most agents)
• Complex full-stack features: 90-120 minutes (runs all agents)

Time Savings: 20-40 minutes for clearly typed features by skipping irrelevant interviews

Original Full Suite (without classification): 85-120 minutes for all features

Time well spent - prevents bugs, rework, and misunderstandings. Classification ensures you only get relevant questions.

---

Philosophy: Measure twice, cut once. Invest time in comprehensive planning to build the right thing, right way, with right tests, first time.