class_seven

# Class Seven - Multi-Agent Development Team Class Seven (七班) is a structured multi-agent workflow that treats sub-agents as specialized development team members. ## When to Use Use this skill when: - Complex development tasks requiring multiple perspectives/roles - Tasks needing PM planning + architecture + implementation + testing - Debugging scenarios requiring systematic investigation - Code review and quality assurance workflows - Projects requiring end-to-end delivery (plan → build → test → deploy) ## Team Structure ``` Main Session (Manager) ├── PM Agent (产品经理) ├── Architect Agent (架构师) ├── Developer Agent (开发工程师) ├── Tester Agent (测试工程师) └── Debugger Agent (调试专家) ``` ## Workflow Phases ### Phase 1: Task Analysis & Planning 1. **Manager (Main Session)** analyzes task complexity 2. Spawn **PM Agent** for requirement clarification 3. PM returns: requirements doc, scope, acceptance criteria ### Phase 2: Architecture & Design 1. Spawn **Architect Agent** with PM output 2. Architect returns: tech stack, module design, interfaces ### Phase 3: Implementation 1. Spawn **Developer Agent** with architecture specs 2. Developer returns: implemented code ### Phase 4: Quality Assurance 1. Spawn **Tester Agent** with code + requirements 2. Tester returns: test plan, test cases, bugs found ### Phase 5: Debugging (if needed) 1. Spawn **Debugger Agent** with bug reports 2. Debugger returns: root cause analysis, fixes ### Phase 6: Integration & Delivery 1. Manager reviews all outputs 2. Integrates final deliverable 3. Validates against acceptance criteria ## Tool Selection Matrix | Task Type | Primary Tool | Secondary Tool | Reason | |-----------|-------------|----------------|--------| | Complex architecture | Claude Code | Kimi | Deep reasoning, context management | | Quick prototyping | Kimi | Native | Fast iteration, lower latency | | Deep debugging | Claude Code | Kimi | Multi-file analysis, bug tracing | | Code review | Kimi | Claude Code | Pattern recognition, best practices | | Testing | Native | Kimi | Deterministic execution | | Documentation | Kimi | Native | Chinese/English bilingual | ## Agent Personas ### PM Agent ``` Role: 产品经理 Expertise: Requirements analysis, user stories, acceptance criteria Output: PRD, user stories, scope definition Tools: Kimi (for Chinese context), Claude Code (for complex products) ``` ### Architect Agent ``` Role: 架构师 Expertise: System design, tech stack selection, API design Output: Architecture doc, module diagrams, interface specs Tools: Claude Code (preferred for architecture), Kimi (for validation) ``` ### Developer Agent ``` Role: 开发工程师 Expertise: Code implementation, refactoring, optimization Output: Production-ready code Tools: Claude Code (complex logic), Kimi (quick implementation), Native (boilerplate) ``` ### Tester Agent ``` Role: 测试工程师 Expertise: Test design, edge case identification, quality assurance Output: Test cases, test scripts, bug reports Tools: Native (execution), Kimi (test design), Claude Code (complex scenarios) ``` ### Debugger Agent ``` Role: 调试专家 Expertise: Root cause analysis, performance profiling, bug fixing Output: RCA report, patches, prevention recommendations Tools: Claude Code (deep analysis), Kimi (pattern matching) ``` ## Execution Modes ### Mode A: Full Team (Full Orchestration) All 5 phases executed sequentially. Use for complex projects. ### Mode B: Sprint Team (Dev + Test) Skip PM/Architect phases. Use when requirements are clear. ### Mode C: Firefighter (Debug Only) Debugger agent only. Use for urgent bug fixes. ### Mode D: Review Board (PM + Tester) Code review workflow. Use for quality gates. ## Quick Commands ```bash # Full team deployment class_seven deploy --mode=full --task="<description>" # Sprint mode class_seven deploy --mode=sprint --specs="<requirements>" # Debug mode class_seven deploy --mode=debug --bug="<bug description>" ``` ## Best Practices 1. **Always start with task analysis** - Determine mode and required agents 2. **Pass context explicitly** - Each agent receives relevant previous outputs 3. **Set clear boundaries** - Define what each agent should/shouldn't do 4. **Use appropriate timeout** - Complex tasks need longer timeouts 5. **Review before integration** - Manager validates all outputs ## Error Handling If an agent fails or produces insufficient output: 1. Analyze failure reason 2. Respawn with clearer instructions or different tool 3. Consider breaking task into smaller sub-tasks 4. Escalate to human if stuck after 2 retries ## References - Detailed workflow patterns: See [references/workflows.md](references/workflows.md) - Tool integration guide: See [references/tools-guide.md](references/tools-guide.md) - Example projects: See [references/examples.md](references/examples.md)