Claude Code Team Strategy for Feature Verification

Alternative to the OpenCode pipeline. Uses Claude Code's built-in team orchestration (TeamCreate, Task tools, SendMessage) for parallel feature verification.

Architecture

Team Lead (Opus 4.6)
  ├── tier0-scanner (Haiku 4.5)     # Fast: source file existence checks
  ├── checker-1 (Opus 4.6)          # Full pipeline per feature
  ├── checker-2 (Opus 4.6)          # Parallel checker
  ├── checker-3 (Opus 4.6)          # Parallel checker
  ├── triage-agent (Sonnet 4.5)     # Issue diagnosis
  └── fixer-agent (Opus 4.6)        # Code fixes

How It Differs from OpenCode

Aspect	OpenCode	Claude Code Teams
State management	JSON state files on disk	TaskCreate/TaskList/TaskUpdate in-memory
Parallelism	Sequential (one feature at a time)	Parallel (multiple agents simultaneously)
Orchestration	Prompt-driven subagent calls	Native team messaging (SendMessage)
File access	All agents share filesystem	All agents share filesystem
Cost model	Per-token across models	Per-token, Opus 4.6 primarily
Session limits	Unlimited (persistent state)	Context window limits (use /compact)
Best for	Long-running unattended pipelines	Interactive sessions with parallelism

Execution Plan

Phase 1: Setup (Team Lead)

1. TeamCreate: "feature-verify-<module>"
2. TaskCreate: One task per feature in the module
3. Spawn tier0-scanner agent
4. Wait for Tier 0 results
5. Filter: remove not_implemented features

Phase 2: Parallel Checking (3 Checker Agents)

1. Spawn 3 checker agents
2. Each checker claims tasks from TaskList (lowest ID first)
3. For each feature:
   a. Read feature .md file
   b. Run Tier 1: dotnet build + dotnet test
   c. Run Tier 2: Playwright/CLI/API (if applicable)
   d. TaskUpdate: status=completed or note failures
   e. Claim next task
4. Checkers go idle when no tasks remain

Phase 3: Triage + Fix (if failures found)

1. Team lead reviews completed tasks for failures
2. For each failure:
   a. TaskCreate: triage task with failure details
   b. Send to triage-agent
   c. triage-agent reads source, returns diagnosis
   d. Team lead reviews diagnosis
   e. TaskCreate: fix task with confirmed diagnosis
   f. Send to fixer-agent
   g. fixer-agent implements fix
   h. Team lead re-checks via checker agent

Phase 4: Cleanup

1. Move passed features: unchecked/ -> checked/
2. Move not_implemented: unchecked/ -> unimplemented/
3. Update state summary
4. Shutdown all agents
5. TeamDelete

Claude Code Prompt (Copy-Paste Ready)

Use this prompt to start the team in Claude Code:

You are verifying features for the <MODULE> module of Stella Ops.

Read docs/qa/feature-checks/FLOW.md for the full state machine and tier system.

Your workflow:
1. Create team "verify-<module>"
2. Create one task per feature file in docs/features/unchecked/<module>/
3. Spawn a tier0-scanner (haiku) to verify source files exist for all features
4. After Tier 0, spawn 3 checker agents (opus) in parallel to run Tier 1 (build+test)
5. For features that fail, spawn a triage agent (sonnet) to diagnose
6. For confirmed issues, spawn a fixer agent (opus) to implement fixes
7. Re-check fixed features
8. Move passed features to docs/features/checked/<module>/
9. Report final status and shutdown team

For each feature, write run artifacts to docs/qa/feature-checks/runs/<module>/<feature>/

State file: docs/qa/feature-checks/state/<module>.json

IMPORTANT:
- Feature files are at docs/features/unchecked/<module>/*.md
- Each has Implementation Details with source file paths
- Each has an E2E Test Plan with verification steps
- Source code is under src/
- .NET 10 backend, Angular 21 frontend
- Use dotnet build/test for backend, ng build/test for frontend

Recommended Test Modules (Side-by-Side Comparison)

For testing both pipelines simultaneously on different modules:

OpenCode Pipeline: `gateway` (8 features)

Pure backend, no Playwright needed
Small enough to complete in one session
Has rate limiting + circuit breaker logic (meaningful checks)
Features: router-back-pressure-middleware, stellarouter-performance-testing-pipeline, + 6 existing

Claude Code Teams: `graph` (7 features)

Pure backend, no Playwright needed
Similar size to gateway
Has graph data structures (meaningful checks)
Features: graph-edge-metadata-with-reason-evidence-provenance, + 6 existing

Both modules are:

Small (7-8 features each) - completable in one session
Backend-only - no Playwright/environment complexity
Meaningful - real logic to verify, not just config
Independent - no cross-module dependencies

Alternative Pair (if you want frontend testing):

OpenCode: exportcenter (7 features) - has CLI+UI surface
Claude Code: vexlens (7 features) - has truth-table tests + UI

State File Compatibility

Both strategies use the SAME state file format (docs/qa/feature-checks/state/<module>.json) and artifact format (docs/qa/feature-checks/runs/<module>/<feature>/<runId>/).

This means you can:

Start with OpenCode on module A
Start with Claude Code on module B
Compare results using the same state format
Switch strategies mid-stream if one works better

5.3 KiB Raw Blame History