Research Question: RQ-external-tdd-workflows-opus5
Can the inner TDD loop of EXACT Coding be substituted by an externally authored TDD workflow, and what does the substitution cost or buy? Example mapping stays the entry point; only the implement/test/refactor loop is exchanged. Measured on claim-office-example-mapping against the current exact-coding baseline exact-hybrid-v2.4-lab-split-cc — on correctness, code quality, TDD discipline and cost.
claim-office-example-mapping
| n, run dates | Correctness | TDD discipline | Code quality | Cost | ||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ↑ | ↑ | ↑ | ↓ | ↓ | ↓ | ↓ | ↓ | ↓ | ↓ | ↓ | ↓ | |
| exact-hybrid-v2.4-lab-split-cctest listn = 5, 2026-09-03 → 09-04 | 96% ± 4 | 100%5/5 | 100%478/480 | 4.49 ± 0.54 🏆 | 17.6 ± 4.39 🏆 | 2.80 ± 0.84 🏆 | 3.40 ± 0.55 🏆 | 0.00 ± 0.00 🏆 | 821 ± 110.71 | 64.0 ± 25.4 min | 140.9M ± 46.4M | $92.95 ± 31.58 |
| external-superpowers-2026-09-04-ccad hocn = 5, 2026-09-03 → 09-04 | 100% ± 0 🏆 | 100%5/5 | n/c | 7.90 ± 1.15 | 23.4 ± 3.13 | 6.20 ± 2.17 | 5.20 ± 1.10 | 0.00 ± 0.00 🏆 | 666 ± 25.53 | 9.1 ± 0.9 min 🏆 | 12.2M ± 1.3M 🏆 | $8.76 ± 1.06 🏆 |
| external-pocock-2026-09-04-ccad hocn = 5, 2026-09-03 → 09-04 | 100% ± 0 🏆 | 100%5/5 | n/c | 10.4 ± 1.45 | 26.6 ± 4.22 | 6.60 ± 2.41 | 5.40 ± 1.14 | 0.20 ± 0.45 🏆 | 600 ± 59.52 🏆 | 9.7 ± 1.1 min 🏆 | 12.6M ± 1.4M 🏆 | $9.86 ± 1.10 🏆 |
| external-kesseler-2026-09-30-ccad hoc0 runs | Not run | Not run | Not run | Not run | Not run | Not run | Not run | Not run | Not run | Not run | Not run | Not run |
Runs behind this table
- 2026-09-03_23-16-50_claim-office-example-mapping_v10-pocock-tdd_opus-5-no-thinking
- 2026-09-03_23-16-50_claim-office-example-mapping_v11-superpowers-tdd_opus-5-no-thinking
- 2026-09-03_23-16-54_claim-office-example-mapping_v6.1.1-lab-split-cc_opus-5-no-thinking
- 2026-09-04_06-20-43_claim-office-example-mapping_v6.1.1-lab-split-cc_opus-5-no-thinking
- 2026-09-04_06-20-44_claim-office-example-mapping_v6.1.1-lab-split-cc_opus-5-no-thinking
- 2026-09-04_06-20-44_claim-office-example-mapping_v6.1.1-lab-split-cc_opus-5-no-thinking-2
- 2026-09-04_06-20-44_claim-office-example-mapping_v6.1.1-lab-split-cc_opus-5-no-thinking-3
- 2026-09-04_07-05-55_claim-office-example-mapping_v11-superpowers-tdd_opus-5-no-thinking
- 2026-09-04_07-07-48_claim-office-example-mapping_v11-superpowers-tdd_opus-5-no-thinking
- 2026-09-04_07-15-53_claim-office-example-mapping_v10-pocock-tdd_opus-5-no-thinking
- 2026-09-04_07-16-22_claim-office-example-mapping_v10-pocock-tdd_opus-5-no-thinking
- 2026-09-04_07-19-30_claim-office-example-mapping_v11-superpowers-tdd_opus-5-no-thinking
- 2026-09-04_07-27-10_claim-office-example-mapping_v11-superpowers-tdd_opus-5-no-thinking
- 2026-09-04_07-59-56_claim-office-example-mapping_v10-pocock-tdd_opus-5-no-thinking
- 2026-09-04_08-23-18_claim-office-example-mapping_v10-pocock-tdd_opus-5-no-thinking
Findings
Findings — RQ-4.7: Substituting the Inner TDD Loop (opus-5)
All figures: claim-office-example-mapping × opus-5-no-thinking (native
subscription route), n=5 per cell. Both external workflows are vendored
snapshots at the commits named in README.md; every statement here
describes those snapshots, not the tools in general.
Overview
Primary outcome is Correctness (external); the decomposition metrics follow the binding quality metric from RQ-architecture-axis-opus5 F-1.6.
| Metric | exact-hybrid-v2.4-lab-split-cc (per-cycle, subagent) |
external-superpowers-2026-09-04-cc (per-cycle, inline) |
external-pocock-2026-09-04-cc (no refactor) |
|---|---|---|---|
Correctness (external) verification_pct — higher = better |
0.96 ± 0.04 | 1.00 ± 0.00 🏆 | 1.00 ± 0.00 🏆 |
| perfect runs | 2/5 | 5/5 🏆 | 5/5 🏆 |
Correctness (internal) tests_passing |
100 % 🏆 | 100 % 🏆 | 100 % 🏆 |
avg_loc_per_function — lower = better |
4.49 ± 0.54 | 7.90 ± 1.15 | 10.41 ± 1.45 |
longest_function — lower = better |
17.60 ± 4.39 | 23.40 ± 3.13 | 26.60 ± 4.22 |
cognitive_max — lower = better |
2.80 ± 0.84 | 6.20 ± 2.17 | 6.60 ± 2.41 |
mccabe_max — lower = better |
3.40 ± 0.55 | 5.20 ± 1.10 | 5.40 ± 1.14 |
| Smell Total — lower = better | 0.00 ± 0.00 | 0.00 ± 0.00 🏆 | 0.20 ± 0.45 |
| Code Mass (APP) — lower = better | 821 ± 111 | 666 ± 26 | 600 ± 60 🏆 |
duration_seconds — lower = better |
3841 ± 1523 | 548 ± 57 🏆 | 582 ± 66 🏆 |
total_tokens — lower = better |
140.9 M ± 46 M | 12.2 M ± 1.3 M 🏆 | 12.6 M ± 1.4 M 🏆 |
refactorings_applied — design characteristic |
33.00 ± 14.27 | 4.20 ± 3.42 | 0.00 ± 0.00 |
test_blocks |
48.40 ± 2.07 | 13.40 ± 2.51 | 19.00 ± 2.74 |
test_cases_total |
49.00 ± 2.00 | 45.00 ± 11.51 | 36.80 ± 5.26 |
test_cases_first_block |
1.00 ± 0.00 | 1.00 ± 0.00 | 1.00 ± 0.00 |
red_unverified — lower = stricter |
0.00 ± 0.00 | 1.00 ± 1.73 | 0.20 ± 0.45 |
Why the quality rows carry no trophy. The gating rule awards quality and cost trophies only to cells at
verification_pct = 1.0.hybrid-v2.4sits at 0.96 with only 2/5 perfect runs — that is not a rounding remainder but a real correctness shortfall in 3 of 5 runs.hybrid-v2.4is therefore not trophy-eligible, yet it holds the best absolute values on all four decomposition metrics. Awarding a trophy to the best eligible cell would put it on the worse value of the row, which the convention excludes — so these rows stay trophy-free. For cost,Code Mass (APP)andSmell Totalthe conflict does not arise: there the best cell is eligible anyway.
refactorings_appliedcarries no trophy: the three values are the cells' design characteristic, not a result. 33 / 4.2 / 0 is the axis itself.
F-4.7.1 — The inner loop is substitutable without losing correctness
Both external workflows reach verification_pct 1.00 in 5/5 runs. The internal baseline hybrid-v2.4 sits below that at 0.96 (2/5 perfect).
| perfect runs | verification_pct |
|
|---|---|---|
external-superpowers-2026-09-04-cc |
5/5 | 1.00 ± 0.00 |
external-pocock-2026-09-04-cc |
5/5 | 1.00 ± 0.00 |
exact-hybrid-v2.4-lab-split-cc |
2/5 | 0.96 ± 0.04 |
Reading: the value EXACT Coding adds lies in the example mapping and the test list, not in its own red/green plumbing. An externally authored loop carries the method on this kata at least as reliably. H5 confirmed for all three cells.
The three hybrid-v2.4 runs at 0.9333 fail on the same acceptance-scenario pattern as the case documented in RQ-4.5 F-1.4; the effect is therefore not new, but it hits hybrid-v2.4 more often than the two external cells.
F-4.7.2 — Refactor position determines decomposition monotonically
Across the three cells all four decomposition and complexity metrics fall monotonically with refactor frequency.
refactorings_applied |
avg_loc_per_function |
longest_function |
cognitive_max |
mccabe_max |
|
|---|---|---|---|---|---|
hybrid-v2.4 per-cycle, subagent |
33.00 | 4.49 | 17.60 | 2.80 | 3.40 |
superpowers-2026-09-04 per-cycle, inline |
4.20 | 7.90 | 23.40 | 6.20 | 5.20 |
pocock-2026-09-04 no refactor |
0.00 | 10.41 | 26.60 | 6.60 | 5.40 |
The clean test of position is superpowers-2026-09-04 ↔ pocock-2026-09-04 — same architecture (one inline skill), only the position varies. avg_loc_per_function 7.90 against 10.41 is the most robust single result of this pair (gap 2.51 at σ ≈ 1.3). longest_function, cognitive_max and mccabe_max point the same way but sit within 1 σ.
H1 confirmed: a refactor stage has an effect. H2 confirmed: pocock-2026-09-04 is the field's quality minimum on all four metrics. The design doctrine in the prompt ("deep modules", "small interfaces") does not replace the stage.
F-4.7.3 — The isolated subagent architecture buys decomposition, and it is expensive
hybrid-v2.4 ↔ superpowers-2026-09-04 varies architecture and mechanism at constant position (both refactor per cycle). The difference is large in both directions.
avg_loc_per_function |
duration_seconds |
total_tokens |
refactorings_applied |
|
|---|---|---|---|---|
hybrid-v2.4 phase commands + subagent |
4.49 ± 0.54 | 3841 ± 1523 | 140.9 M ± 46 M | 33.00 ± 14.27 |
superpowers-2026-09-04 one inline skill |
7.90 ± 1.15 | 548 ± 57 | 12.2 M ± 1.3 M | 4.20 ± 3.42 |
| Factor | 0.57× | 7.0× | 11.6× | 7.9× |
The answer to the RQ's guiding question is therefore twofold: the subagent apparatus does buy measurably better decomposition (4.49 against 7.90, ≈ 3 σ) — but at the price of 7× wallclock and 10× tokens, with worse Correctness (external) at the same time. H3 in the variant "per-cycle refactoring alone suffices" is refuted: superpowers-2026-09-04 refactors per cycle and still lands clearly outside the hybrid-v2.4 level. H4 confirmed (superpowers-2026-09-04 markedly cheaper than hybrid-v2.4).
The σ values are part of the result: relative to its mean, hybrid-v2.4 spreads three to four times wider on duration (± 1523 s) and tokens (± 42 M) than superpowers-2026-09-04. The apparatus is not only more expensive, its cost is also less predictable.
F-4.7.4 — The review stage costs more than the missing refactor saves
pocock-2026-09-04 has no refactor stage, but two review subagents at the end. It is still not the cheapest cell.
duration_seconds |
total_tokens |
|
|---|---|---|
superpowers-2026-09-04 per-cycle refactor, no review |
548 ± 57 | 12.2 M ± 1.3 M |
pocock-2026-09-04 no refactor, two review subagents |
582 ± 66 | 12.6 M ± 1.4 M |
H8 (pocock-2026-09-04 is the cheapest cell) is not confirmed: pocock-2026-09-04 sits above superpowers-2026-09-04 on both wallclock and tokens, both gaps within 1 σ. Reading: the two review subagents cost about as much as the saved per-cycle refactoring yields — and deliver no code, because by construction they only report.
The token row is the one this RQ had to re-measure: pocock-2026-09-04 spends its review budget inside two subagents, and until 2026-09-30 subagent tokens were absent from total_tokens entirely (RQ-old-vs-new-exact-line-opus55 F-4.12.5). On the uncorrected figure this cell read 11.8 M and undercut superpowers-2026-09-04, which is the one arrangement of the numbers that would have argued against this finding. Dropping the review stage would give the cheapest variant of the field; with it, pocock-2026-09-04 is cost-neutral against superpowers-2026-09-04 and worse on every quality metric.
F-4.7.5 — Superpowers keeps cycle discipline but does not write tests in one block
The manual n=1 observation that Superpowers writes all tests at once does not reproduce.
test_blocks |
test_cases_total |
test_cases_first_block |
cases per block | |
|---|---|---|---|---|
hybrid-v2.4 |
48.40 ± 2.07 | 49.00 ± 2.00 | 1.00 ± 0.00 | 1.01 |
superpowers-2026-09-04 |
13.40 ± 2.51 | 45.00 ± 11.51 | 1.00 ± 0.00 | 3.36 |
pocock-2026-09-04 |
19.00 ± 2.74 | 36.80 ± 5.26 | 1.00 ± 0.00 | 1.94 |
test_cases_first_block is exactly 1 in 15/15 runs: no workflow starts with a test block. H6 is therefore refuted — the falsifier (test_blocks = 1 or first block ≈ total count) occurs in no run.
The step size nevertheless differs clearly: hybrid-v2.4 stays at one case per block, superpowers-2026-09-04 writes 3.36 on average. The skill's script demands "one behavior" per test; superpowers-2026-09-04 reads that noticeably more broadly than the phase commands, without skipping the red phase.
red_unverified stays low but not at zero: hybrid-v2.4 0.00, pocock-2026-09-04 0.20 ± 0.45, superpowers-2026-09-04 1.00 ± 1.73. The spread at superpowers-2026-09-04 comes from a single run; H7 holds for hybrid-v2.4 and pocock-2026-09-04 and is only weakly supported for superpowers-2026-09-04.
F-4.7.6 — Little code is not a quality signal here
The Code Mass ordering runs opposite to the complexity ordering.
| Code Mass (APP) | avg_loc_per_function |
|
|---|---|---|
hybrid-v2.4 |
821 ± 111 | 4.49 |
superpowers-2026-09-04 |
666 ± 26 | 7.90 |
pocock-2026-09-04 |
600 ± 60 | 10.41 |
pocock-2026-09-04 writes the least and packs it into the longest, most complex functions; hybrid-v2.4 writes the most and distributes it most finely. Consequence for the analysis: on this kata Code Mass (APP) alone does not separate "parsimonious" from "compacted". Without the decomposition metrics next to it, pocock-2026-09-04 would read as the leaner result — it is the unstructured one.