Skip to content

Releases: Koroqe/claude-code-sdlc

v3.1.0 — Execution Waves, Pipeline Hardening, Model Tiers

19 May 22:21
@Koroqe Koroqe
v3.1.0
2f95b61

Choose a tag to compare

View all tags
v3.1.0 — Execution Waves, Pipeline Hardening, Model Tiers Latest
Latest

Turn Claude Code into a full software development team.

13 specialized AI agents. Documentation-first. TDD. Quality gates. Hardened against Claude Code's known failure modes.

Install

curl -fsSL https://raw.githubusercontent.com/Koroqe/claude-code-sdlc/main/install.sh | bash

What's New in v3.1.0

Self-Improvement Loop (in progress — documentation complete, implementation next)

Inspired by Karpathy's Claude Code setup, the pipeline now captures mistakes and turns them into prevention rules that persist across sessions and features.

  • Three capture triggers — user corrections (with concrete detection heuristics), repeated error patterns (same deviation rule 2+ times), quality gate failures
  • Prevention rule elevation — lessons recurring across 2 features (security) or 3 features (general) become permanent rules
  • Prevention rule retirement — stale rules referencing deleted patterns archive automatically after 10 features
  • Read everywhere — prevention rules are checked at session start, during planning, before every slice, and during context-refresh
  • Parallel-safe — orchestrator-only writes during wave execution, matching the scratchpad pattern
  • Backward compatible — all references include existence guards; projects without .claude/lessons.md are unaffected

PRD, use cases (10 scenarios), QA test cases (93 cases), and 8-slice implementation plan are complete. Implementation ships in v3.2.0.

Execution Waves — Parallel Slice Implementation

Independent implementation slices now execute simultaneously. The planner assigns slices to numbered waves based on file dependencies — slices within the same wave touch completely disjoint files and run in parallel via subagent spawning. Wall-clock implementation time drops significantly for features with parallelizable work.

  • Planner wave assignment — post-processing step groups slices by file overlap into waves
  • Wave-aware orchestration — develop-feature spawns parallel subagents per wave, waits for completion, proceeds to next wave
  • Orchestrator-only scratchpad writes — prevents race conditions during parallel execution
  • Failure isolation — a failing slice doesn't abort siblings; successful commits are preserved
  • Plan Critic validation — CRITICAL-severity checks for file overlap within waves and dependency ordering

Pipeline Hardening

  • Goal-backward verification — new verifier agent checks 4 levels: file existence, stub detection, wiring, data flow
  • Graduated error recovery — 4-tier deviation rules replace flat retry loops (auto-fix → auto-add → auto-resolve → escalate)
  • Executable plan format — each slice has Files:, Changes:, Verify:, Done when: fields
  • Scope reduction detection — Plan Critic flags hedging language ("v1", "placeholder", "for now") against PRD requirements

Agent Model Tier Optimization

  • 10 agents moved to Sonnet — structured/mechanical work with well-defined output formats
  • 3 agents stay on Opus — architect, planner, security-auditor (output cascades through the pipeline; mistakes aren't catchable by automated verification)
  • Cost reduction without quality loss — downstream gates catch any Sonnet-produced issues

The 13 Agents

Agent Role
prd-writer Feature requirements in docs/PRD.md
ba-analyst Use cases and scenarios
architect Architecture review, module boundaries
qa-planner Test cases before any code
planner 5-9 executable slices with wave assignment
security-auditor Vulnerability audit, auth boundaries
test-writer TDD — tests before implementation
e2e-runner End-to-end tests from use cases
code-reviewer Quality, security, architecture compliance
build-runner Typecheck, tests, build verification
verifier Goal-backward: file existence, stubs, wiring, data flow
doc-updater Documentation accuracy
refactor-cleaner Post-implementation cleanup

Commands

Command What It Does
/develop-feature Full autonomous pipeline — request to merge-ready
/bootstrap-feature Documentation phases only — PRD, use cases, architecture, QA, plan
/implement-slice Next TDD slice — tests first, implement, verify, commit
/merge-ready All 9 quality gates
/context-refresh Rebuild session context from scratchpad

Hardening Against Claude Code Failure Modes

Failure Mode Fix
False success reports Mandatory typecheck after edits; mid-slice typecheck every 3 files
Context death spiral (~167K tokens) Re-read-before-edit; scratchpad persistence; auto-archiving
Silent file truncation (2K lines) Chunked reads with offset/limit for files >500 LOC
Search truncation (50K chars) Re-run with narrower scope when results look incomplete
Grep misses references 7-step rename protocol: whole-word, barrel files, dynamic imports
Simplicity bias blocks structural fixes Architect [STRUCTURAL] action items authorize fixes
Flat retry loops 4-tier deviation rules: auto-fix, auto-add, auto-resolve, escalate
Vague plans cause drift Executable format: Files, Changes, Verify, Done-when per slice
Features compile but are disconnected 4-level goal-backward verification
Agents silently downgrade scope Plan Critic scans for hedging language against PRD
Sequential execution wastes time Wave-based parallelism with file-overlap safety
Same mistakes repeat across features Self-improvement loop captures corrections as prevention rules

Full documentation: README

Assets 2
Loading