The spec-driven framework for
scope precision and quality.
Built for complex, high-quality codebases. Every requirement becomes a traceable, atomically-committed task, then a second agent checks the result. In our 4-framework benchmark, the most consistent — highest average score and the best test completeness. Works with any stack, on the agents we support.
npx @tech-leads-club/agent-skills install --skill tlc-spec-drivenWorks with Cursor, Claude Code, Copilot, Windsurf, Cline and 14 others.
Maps the full scope
Specify turns a request into testable requirements with unique IDs, including the edge cases and implicit requirements the request usually leaves out. An explicit out-of-scope table stops creep before it starts.
Ambiguity gets resolved, not skipped
A requirement closure gate means nothing leaves the spec silently ambiguous: every open question is resolved with you or logged as a signed-off assumption. Declined gray areas are recorded, not dropped.
An independent verifier checks the work
After the last task, a fresh read-only sub-agent verifies the build. The author is never the verifier. It runs a spec-anchored outcome check and injects faults to confirm your tests actually catch them, then returns a verdict.
Tests that actually discriminate
Every task passes a Test Adequacy review that is necessary and sufficient: every acceptance criterion asserted, no shallow tests, no tests without a requirement. Highest test completeness in our benchmark (T = 0.90), with a perfect 12/12 on real outcome assertions.
Self-improving lessons layer
Verification failures become terse, project-local lessons that auto-load into future specs and designs. The framework gets sharper on your codebase the more you use it, with no external dependencies.
Traceability, spec to commit
Every requirement ID flows from spec to design to task to commit, so every change traces back to a sanctioned requirement, and the independent verifier flags anything that drifts.
How it works
A flow that auto-sizes to complexity: scope mapped up front, quality verified independently at the end.
Map the full scope
Requirements, edge cases, and an explicit out-of-scope table. Always required. The agent generates testable requirement IDs that every downstream task traces back to.
Architecture & reuse
Component design, data flow, code reuse, and risk mitigation for fragile areas. Auto-skipped for straightforward changes, with no boilerplate when there's nothing to decide.
Atomic breakdown
Atomic tasks with dependencies, co-located tests, and binary verification criteria. Auto-skipped when there are ≤3 obvious steps, so they become implicit in Execute.
Implement
One task at a time, gated by the test runner before every atomic commit. Tests derive from the spec and each task passes an adequacy review before moving on. Always required.
Independent verification
A fresh read-only sub-agent (never the author) checks outcomes against the spec and injects faults to confirm the tests catch them. A second agent checks the build after the last task.
How quality is built and ensured
Quality is not a final review bolted on at the end. The harness learns how your project tests, puts the test in the task, and a second agent checks the result.
It learns how your project tests
Reads your standards
Scans AGENTS.md, .cursor/rules, CONTRIBUTING, test-runner configs, and CI workflows for documented quality and testing rules.
Samples your tests
Studies 5 to 10 existing test files to learn your style, file locations, framework, and per-layer depth, then treats that depth as a floor, never a ceiling.
Discovers your commands
Extracts the real test and gate commands from your manifests and CI instead of guessing an ecosystem. No tests yet? It asks you which types and commands to use.
Built into every task
Co-located, not deferred
Tests ship inside the task that creates the code, and they must satisfy the required coverage expectation for that layer, not merely exist. "Tested later" is rejected.
Spec-derived assertions
Tests are written from the spec acceptance criteria, never by reading the code. Each assertion targets the exact spec-defined outcome.
Test Adequacy Review
Every task passes a necessary-and-sufficient review: each criterion covered with file:line evidence (evidence-or-zero), and every test traced back to a requirement. No scope creep.
Non-shallow litmus
Assertions that would still pass under a wrong implementation are rejected. Asserting a value or persisted state, never just that a mock was called.
Ensured independently
Deterministic gate
The test runner decides, not the agent. A task cannot be committed until its gate (quick / full / build) passes, with the test count checked so nothing is silently deleted.
Independent Verifier
After the last task, a fresh read-only sub-agent runs automatically. Author is never the verifier, so it re-derives coverage from the spec instead of inheriting the author assumptions.
Discrimination sensor
The Verifier injects behavior-level faults into a throwaway copy and confirms the tests catch them. Surviving mutants become fix tasks: proof the suite detects regressions.
Bounded fix loop
Gaps route back as fix tasks and the Verifier re-runs, capped at 3 iterations before escalating to you. Every grounded failure is distilled into a reusable, project-local lesson.
Simplicity that augments models.
As models get smarter, you don't need more harness, you need the right one. One skill, installed once. No extra product to learn — the agent runs the flow.
Results, in numbers
Benchmarked against other spec-driven development frameworks on a real, non-trivial PRD. TLC 3.* runs in its recommended role-split (Opus 4.8 plans, Sonnet 4.6 implements); the other frameworks run on Sonnet 4.6. Three end-to-end runs each, scored by an auditable binary-check LLM judge.
Average score across 3 runs
Bars show the 3-run average, the consistency-fair view. Hover for each peak run. TLC 3.* leads on the mean (0.94); TLC 2.* shown for comparison.
Consistency across 3 runs
Dots = the three independent runs; diamond = average. Tighter & higher cluster wins. TLC 3.* leads on the mean (0.94); TLC 2.* shown for comparison.
Value: cost vs quality
Tokens (work) vs final score. Top-left is the high-value quadrant.
Implementation vs Tests
Everyone implements well; test completeness is the real differentiator.
Head-to-head: the questions that matter
TLC 3.*: 3 winsBeyond a single number: where each framework actually lands.
Best test completeness (T = 0.90) and 12/12 on outcome tests. Asserts real state, not just calls.
Range 0.93–0.95 across three runs: the highest floor in the field. OpenSpec swings 0.79–0.93.
Top mean (0.94) and the best single run (0.95): TLC 3.* leads on both the repeatable average and the peak, with a clean Scope = pass.
| Framework | Avg (3-run) | Peak | Impl (I) | Tests (T) | Scope | Tokens |
|---|---|---|---|---|---|---|
| TLC 3.*THIS SKILL | 0.94 | 0.95 | 1.00 | 0.90 | pass | ~31M |
| TLC 2.* | 0.89 | 0.90 | 0.92 | 0.72 | partial | ~31M |
| Speckit | 0.87 | 0.88 | 0.96 | 0.63 | partial | ~36M |
| OpenSpec | 0.85 | 0.93 | 0.96 | 0.65 | pass | ~24M |
| Superpowers | 0.84 | 0.86 | 0.94 | 0.58 | partial | ~31M |
Works across models
The comparison above runs TLC 3.* in its recommended Opus→Sonnet role-split. Here we hold the framework at TLC 3.* and vary the single model instead. The skill harness is deliberately thin and optimized for how modern models are designed. It guides without fighting the model's own reasoning. The role-split (Opus plans, Sonnet implements) tops the field at 0.95, and Composer 2.5 is the best value for money (mean 0.945, peak 0.98).
Works across models
Mean Final per model on TLC 3.* (same PRD). Most strong models are Spec-complete; Gemini 3.1 Pro is a poor fit for SDD.
| Model | Runs | Mean Final | Band | Notes |
|---|---|---|---|---|
| Opus → SonnetRECOMMENDED | 1 | 0.95 | Spec-complete | Role-split: Opus plans, Sonnet implements. A strong plan let the cheaper implementer keep quality, matching the best single-model run. |
| Composer 2.5BEST VALUE | 2 | 0.94 | Spec-complete | Best value for money: top single-model mean (peak 0.98, green gates on both runs) at a fraction of the cost of the frontier models. |
| Claude Opus 4.8 | 2 | 0.93 | Spec-complete | Spec-complete on both runs, perfect precision. |
| GPT-5.5 (high) | 2 | 0.93 | Spec-complete | Tightest spread (0.03); spec-complete on both runs. |
| GLM 5.2 (high) | 4 | 0.91 | Spec-complete | Capable but variable (n=4): runs 2–4 average 0.94 with the richest robustness layers measured. |
| Claude Sonnet 4.6 | 2 | 0.87 | Solid | Just below the spec-complete line: thinner test coverage, not missing behavior (I ≈ 0.97). |
| Gemini 3.1 ProAVOID FOR SDD | 2 | 0.54 | Weak | Ignores the spec: green gates but green-but-wrong, with un-wired endpoints, dropped requirements, missing state transitions. Stays Weak on every framework tested, so the limitation is model-driven, not framework-driven. |
Gemini 3.1 Pro is a bad fit for spec-driven development. It passed every engineering gate (build / lint / unit / e2e) yet stayed Weak (0.54) because it ignores the spec, shipping green-but-wrong code: un-wired endpoints, dropped requirements, and missing state transitions. It stayed Weak on a second framework too, so the limitation is model-driven, not framework-driven.
Highest average, most consistent, best tests: TLC 3.* (Opus plans, Sonnet implements) posts a 0.94 mean Final and a 0.93–0.95 range across three independent runs, with the best test completeness in the field (T = 0.90), 12/12 on real outcome assertions, and a clean Scope = pass. v3 adds an independent verifier, a requirement-closure gate, and a self-improving lessons layer.
npx @tech-leads-club/agent-skills install --skill tlc-spec-drivenBenchmark methodology: each framework ran end-to-end 3× on the same non-trivial PRD. TLC 3.* used its recommended role-split (Opus 4.8 plans → Sonnet 4.6 implements); TLC 2.* and the other frameworks used Sonnet 4.6 for both planning and implementation. Quality was scored by an auditable binary-check LLM judge. View skill source →
Ready to build with precision?
Scope mapped. Quality checked. One command, works with your agent today.
npx @tech-leads-club/agent-skills install --skill tlc-spec-driven