From srnnkls-tropos
Subagent-driven task execution with TDD workflow. Dispatches tester subagent (writes failing tests) then implementer subagent (makes tests pass), with batch review.
npx claudepluginhub joshuarweaver/cascade-code-general-misc-2 --plugin srnnkls-troposThis skill uses the workspace's default tool permissions.
Execute specs with proper TDD: tester writes failing tests, implementer makes them pass, reviewers validate.
Creates isolated Git worktrees for feature branches with prioritized directory selection, gitignore safety checks, auto project setup for Node/Python/Rust/Go, and baseline verification.
Executes implementation plans in current session by dispatching fresh subagents per independent task, with two-stage reviews: spec compliance then code quality.
Dispatches parallel agents to independently tackle 2+ tasks like separate test failures or subsystems without shared state or dependencies.
Execute specs with proper TDD: tester writes failing tests, implementer makes them pass, reviewers validate.
Core principle: Three-phase batches with fresh subagents. No batch completes without review.
Use when:
spec-create)Don't use when:
spec-validate → spec-create first)Each batch executes three phases. A batch is NOT complete until all three phases finish.
┌─────────────────────────────────────────────────────────────────┐
│ BATCH N │
├─────────────────────────────────────────────────────────────────┤
│ Phase A: TESTERS (parallel) │
│ ├── Dispatch N task-tester subagents (opus) │
│ ├── Each writes failing tests (RED) │
│ └── Wait for ALL testers │
│ ↓ │
│ Phase B: IMPLEMENTERS (parallel) │
│ ├── Dispatch N task-implementer subagents (opus) │
│ ├── Each receives its tester's report │
│ ├── Each makes tests pass (GREEN) │
│ └── Wait for ALL implementers │
│ ↓ │
│ Phase C: REVIEWERS (parallel) │
│ ├── Dispatch 1 native Claude reviewer (opus) [required] │
│ ├── Dispatch 0-N OpenCode reviewers (from validation.yaml) │
│ ├── Each reviews ALL changes from batch │
│ ├── Wait for ALL reviewers │
│ └── Synthesize feedback │
│ ↓ │
│ Gate: Issues found? │
│ ├── Critical/High → Fix before proceeding │
│ └── None/Medium → Commit and continue │
└─────────────────────────────────────────────────────────────────┘
CRITICAL: All three phases are mandatory. Reviewers are not optional.
./specs/active/*/tasks.yaml from that directorystatus: pending or status: in_progressCRITICAL: Always populate TodoWrite before dispatching any subagents.
feat/<spec-directory-name>Before dispatching any tasks, verify validation.yaml gates:
validation.yaml from spec directorymetadata.issue_typegates sectionstatus: failed:
markers section for status: openParse dependencies.yaml to identify execution batches:
Dependency rules:
[P] marker AND different file paths can run in parallelFor each batch, execute ALL THREE phases:
Single task:
Dispatch 1 task-tester (opus) → wait for completion
Parallel batch (N tasks):
Dispatch N task-testers in SINGLE message → wait for ALL
Each tester:
code-test skillSingle task:
Dispatch 1 task-implementer (opus) with tester report → wait for completion
Parallel batch (N tasks):
Dispatch N task-implementers in SINGLE message → wait for ALL
Each receives its corresponding tester's report
Each implementer:
code-implement skillCRITICAL: Reviewers are mandatory. Every batch gets reviewed.
Get batch diff before dispatching:
# Diff of changes made in this batch (since last batch commit)
git diff <last_batch_commit>..HEAD
Always dispatch ALL reviewers in a SINGLE message for true parallelism:
Dispatch:
- 1 native Claude reviewer (task-reviewer, opus) [required]
- 0-N OpenCode reviewers (models from validation.yaml)
→ Wait for ALL reviewers
Each reviewer:
code-review --diff (batch diff, not full files)Review prompt includes:
Reviewer dispatch configuration:
CRITICAL: Dispatch ALL reviewers in a SINGLE message for true parallelism.
# Single message with multiple tool calls:
# 1. Native Claude reviewer (Task tool) [required]
Task(
subagent_type="task-reviewer",
model={claude_model}, # from review_config (opus)
prompt=review_prompt # includes: batch diff + implementer reports + task specs
)
# 2. OpenCode reviewers (Bash tool, background) [from validation.yaml]
Bash(run_in_background=true):
timeout 1200 opencode run --model "openai/gpt-5.2-codex" --variant {reasoning_effort}-medium "{review_prompt}"
Bash(run_in_background=true):
timeout 1200 opencode run --model "google/gemini-3-pro-preview" --variant {reasoning_effort}-medium "{review_prompt}"
All models and reasoning effort are configured in validation.yaml under review_config.
After ALL reviewers complete:
# ./specs/active/<spec>/review.yaml
batch_reviews:
- batch: <N>
timestamp: <ISO_TIMESTAMP>
commit: <SHA>
tasks: [T001, T002]
reviewers:
- id: claude-opus
status: completed
gates: { correctness: pass, style: pass, ... }
- id: opencode-codex
status: completed | timeout | failed
gates: { ... }
synthesized:
gates: { correctness: pass, style: fail, ... }
critical_issues: <N>
high_issues: <N>
medium_issues: <N>
outcome: approved | changes_requested
issues:
critical: [...]
high: [...]
medium: [...]
deferred_issues: [...] # medium severity
Gate Summary Table:
| Gate | Claude | Codex | Gemini |
|--------------|--------|--------|--------|
| Correctness | pass | fail | pass |
| Style | pass | pass | pass |
| Performance | pass | pass | pass |
| Security | fail | pass | fail |
| Architecture | pass | pass | pass |
If Critical/High issues found:
If only Medium issues:
When batch completes successfully (all phases, review passed):
status: in_progress to status: completedcheckpoint:
spec_name: <spec>
spec_path: ./specs/active/<spec>
branch: feat/<spec>
timestamp: <ISO_TIMESTAMP>
last_batch: <N>
last_commit: <SHA>
tasks:
completed: [...]
pending: [...]
next_batch:
number: <N+1>
tasks: [...]
deferred_issues: [...] # medium severity, noted for later
review_config:
reviewers: [...] # from validation.yaml
<type>(<scope>): <description>
Tasks: <task-ids>
Batch: <N>/<total>
feat(cache): add TTL expiry\n\nTasks: PH2-003, PH2-004\nBatch: 2/5/continue in new session)After ALL batches complete, invoke code-review skill in final mode:
/code.review --final <spec-name>
Or dispatch multi-reviewer pass directly:
Dispatch (in same message):
- 1 native Claude reviewer (opus) [required]
- 0-N OpenCode reviewers (from validation.yaml)
Final review checks:
Write final_review section in review.yaml:
final_review:
status: completed
timestamp: <ISO_TIMESTAMP>
reviewers: [claude-opus, opencode-codex, ...]
gates: { correctness: pass, style: pass, ... }
spec_compliance:
all_tasks_complete: true
acceptance_criteria_met: true
edge_cases_handled: true
issues: [...]
strengths: [...]
overall_assessment: "Implementation complete and verified"
recommendation: ready_to_merge | changes_requested
readiness:
all_batches_reviewed: true
critical_issues_resolved: true
high_issues_resolved: true
final_review_passed: true
tests_passing: true
| Role | Subagent Type | Model | Skill |
|---|---|---|---|
| Tester | task-tester | opus | code-test |
| Implementer | task-implementer | opus | code-implement |
| Reviewer | task-reviewer | from review_config (opus) | code-review |
CRITICAL: Always specify model: opus for testers, implementers, and reviewers.
| Gate | When | Action if Failed |
|---|---|---|
| Pre-impl gate | Before any dispatch | Block if Initiative gates failed |
| RED verification | After tester | Verify tests actually fail |
| GREEN verification | After implementer | Verify tests pass |
| Batch review | After all implementers | Fix before next batch |
| Final review | After all batches | Address gaps |
Never:
If tester can't write tests:
If reviewers timeout:
[Load spec, create TodoWrite, checkout branch]
Batch 1: Task 1 (single task)
├── Phase A: Dispatch tester (opus)
│ └── Tester: Wrote 3 tests, all failing (RED)
├── Phase B: Dispatch implementer (opus) + tester report
│ └── Implementer: Made tests pass (GREEN)
├── Phase C: Dispatch reviewers (3 in parallel)
│ ├── Claude: approved, no issues
│ ├── Codex: approved, 1 minor issue
│ └── Gemini: approved, no issues
├── Synthesize: 1 minor issue (note for later)
└── Commit: feat(cache): add caching layer
Batch 2: Tasks 2, 3, 4 ([P] parallel batch)
├── Phase A: Dispatch 3 testers (single message)
│ └── All testers complete with failing tests
├── Phase B: Dispatch 3 implementers (single message)
│ └── All implementers complete, tests passing
├── Phase C: Dispatch reviewers (3 in parallel)
│ ├── Claude: changes_requested, 1 critical
│ ├── Codex: changes_requested, 1 critical (same issue)
│ └── Gemini: approved
├── Synthesize: 1 critical issue (found by 2 reviewers)
├── Fix: Dispatch fix subagent → verify
└── Commit: feat(api): add endpoints for tasks 2, 3, 4
...
[Final review - 3 reviewers in parallel]
All requirements met
Use with:
spec-validate → spec-create - Create spec before dispatchclarify - Resolve markers/gates before dispatchcode-test - Tester invokes for TDD methodologycode-implement - Implementer invokes for language guidelinescode-review - Reviewer invokes for review methodologytask-completion-verify - Verify before claiming done