Workflows
Baselines
baseline-oneshot-v1-cconeshotClaude Codead hocbranch
A one-shot baseline for Claude Code (arm: oneshot). The agent reads the exercise, implements the solution in a single autonomous pass and runs whatever verification it finds appropriate. Tests are not required. There is no test list, no phase structure, no refactoring rules and no subagents.
baseline-end-refactor-only-v1-agent-ccend-refactor-onlyClaude Codead hocbranchparent: baseline-oneshot-v1-cc
A test-after baseline for Claude Code (arm: end-refactor-only). It has three sequential phases and no cycle. First the agent implements the solution without tests. Then it writes a test suite from the specification, with a test for every spec example and every clarifying question, and gets it green. Last comes a single refactoring pass. That pass runs in an isolated refactoring subagent with a fresh context and applies the Four Rules of Simple Design, the Absolute Priority Premise, a naming evaluation and a mandatory refactoring attempt.
baseline-end-refactor-only-v1-native-ccend-refactor-onlyClaude Codead hocbranchparent: baseline-oneshot-v1-cc
A variant of baseline-end-refactor-only-v1-agent (arm: end-refactor-only) that changes one thing: the final refactoring pass runs as a slash command inside the main session instead of in a subagent. The refactoring content, the phase order and the timing are unchanged.
baseline-iterative-v1-cciterativeClaude Codead hocbranch
A plan-and-checklist baseline for Claude Code (arm: iterative). The agent breaks the exercise into a checklist of discrete steps, works through it one item at a time and ticks each one off. It runs whatever verification it finds appropriate. Tests are not required, and there are no TDD phases, no refactoring rules and no subagents; everything runs in one context.
baseline-inline-tdd-v1-ccinline-tddClaude Codead hocbranch
A minimal TDD baseline for Claude Code (arm: inline-tdd). The agent is only told to solve the exercise test-driven and autonomously. No test list, no phase structure, no refactoring rules, no subagents — how TDD is done is left to the model.
baseline-inline-tdd-v1-piinline-tddpiad hocbranchparent: baseline-inline-tdd-v1-cc
The pi port of baseline-inline-tdd-v1 (arm: inline-tdd). It gives the same minimal instruction to solve the exercise test-driven and autonomously. Only the packaging differs: a pi AGENTS.md replaces the Claude Code rules file, and it adds a line to work test by test plus a note on the CLI entry-point contract.
baseline-inline-tdd-v1.1-local-git-ccinline-tddClaude Codead hocbranchparent: baseline-inline-tdd-v1-cc
The same minimal TDD instruction as baseline-inline-tdd-v1-cc (arm: inline-tdd, Claude Code), run under a different harness condition: the run directory is an isolated local Git repository with an initial commit.
baseline-inline-tdd-v1.1-local-git-piinline-tddpiad hocbranchparent: baseline-inline-tdd-v1.1-local-git-cc
The same minimal TDD instruction as baseline-inline-tdd-v1-pi (arm: inline-tdd, pi), run under a different harness condition: the run directory is an isolated local Git repository with an initial commit.
External skills
external-kesseler-2026-09-30-cckesselerClaude Codead hocvendored
An external workflow for Claude Code (arm: kesseler): Lada Kesseler's TDD skill from lexler/skill-factory, commit 474433af2e (Apache-2.0), vendored unchanged together with its ZOMBIES reference; the upstream eval files are not included. Tests are planned up front as one-line test comments and checked for completeness against ZOMBIES. They are then worked through one at a time, with predicted failures, a two-step Red (first a compile failure, then an assertion failure), a simplify step and a refactor at every green. A final evaluation looks for missed tests and hardcoded values. Everything runs inline in one context. The lab runs the skill in its auto mode, treats the prompt as the approved plan and supplies the test command.
external-pocock-2026-09-04-ccpocockClaude Codead hocvendored
An external workflow for Claude Code (arm: pocock): the tdd, code-review and codebase-design skills from Matt Pocock's mattpocock/skills, commit 6654f6b6 (MIT), vendored unchanged. Red–Green works in vertical slices, one test at a time, at seams agreed in advance. There is no up-front test list, and refactoring is explicitly not part of the loop. Once the suite is green, a code review runs in two parallel subagents, one for coding standards and one for the spec, and reports its findings without acting on them. The lab adds autonomous execution, takes the seams from the prompt, points the review at the written files and the prompt instead of a Git diff and an issue tracker, and supplies the test command.
external-superpowers-2026-09-04-ccsuperpowersClaude Codead hocvendored
An external workflow for Claude Code (arm: superpowers): the test-driven-development skill from Jesse Vincent's Superpowers collection, release v6.3.0 (MIT), vendored unchanged. Red–Green–Refactor under a strict test-first rule — code written before its test is deleted. No up-front test list; the next test is chosen as work proceeds, all inline in one context. The lab only replaces the human-in-the-loop checkpoints with autonomous execution.
external-tcr-kentbeck-2026-09-14-cctcr-kentbeckClaude Codead hocvendored
An external workflow for Claude Code (arm: tcr-kentbeck): the tcr-kentbeck skill from Pietro Di Bello's xpepper/tcr-skill, commit 48c16c0 (MIT), vendored unchanged. It is classic TCR: tiny steps, each run against the full suite, and every reverted step is appended to a failure log. Test-first is not required. There is no test list, no phase structure and no refactoring rules, and everything runs in one context. The lab adds only autonomous execution, the test command and an isolated local Git repository to commit into.
external-tcr-kentbeck-2026-09-14-pitcr-kentbeckpiad hocvendoredparent: external-tcr-kentbeck-2026-09-14-cc
The pi port of external-tcr-kentbeck-2026-09-14 (arm: tcr-kentbeck). It uses the same vendored skill and the same method. Only the packaging differs: the skill sits under pi skills, and the lab adaptation lives in AGENTS.md, which adds a reminder that a checkpoint does not end the run.
external-tcrdd-bsene-2026-09-14-cctcrdd-bseneClaude Codead hocvendored
An external workflow for Claude Code (arm: tcrdd-bsene): the tcrdd skill from the bsene/skills repository, commit 81a792d, vendored unchanged; that upstream snapshot declares no license. It is TCRDD on plain Git with no external tool. Each Red, Green and Refactor phase stages all changes and runs the suite. It commits when the result is what the phase expects; otherwise it hard-resets and logs the failure. Green follows a transformation-priority ladder. There is no up-front test list, and everything runs in one context. The lab runs the skill in its own autonomous mode with the approval gates skipped and supplies the test command.
external-tcrdd-bsene-2026-09-14-pitcrdd-bsenepiad hocvendoredparent: external-tcrdd-bsene-2026-09-14-cc
The pi port of external-tcrdd-bsene-2026-09-14 (arm: tcrdd-bsene). It uses the same vendored skill and the same method. Only the packaging differs: the skill sits under pi skills, and the lab adaptation lives in AGENTS.md, which adds a reminder that a phase checkpoint does not end the turn.
external-tcrdd-git-gamble-2026-09-14-cctcrdd-gambleClaude Codead hocvendored
An external workflow for Claude Code (arm: tcrdd-gamble): the tcr skill from Pietro Di Bello's xpepper/tcr-skill, commit 48c16c0 (MIT), vendored unchanged. It is TCRDD driven by the git-gamble tool. Every Red, Green and Refactor step bets on its expected test outcome, then commits if the bet holds and reverts if it does not; a new test that passes straight away is reverted too. There is no up-front test list and no refactoring rules beyond keeping behaviour unchanged, and everything runs in one context. The lab adds autonomous execution, the test command, an installed git-gamble and an isolated local Git repository.
external-tcrdd-git-gamble-2026-09-14-pitcrdd-gamblepiad hocvendoredparent: external-tcrdd-git-gamble-2026-09-14-cc
The pi port of external-tcrdd-git-gamble-2026-09-14 (arm: tcrdd-gamble). It uses the same vendored skill and the same method. Only the packaging differs: the skill sits under pi skills, and the lab adaptation lives in AGENTS.md, which adds a reminder that a phase checkpoint does not end the turn.
EXACT Coding — Opus line
exact-subagents-v1-ccsubagentsClaude Codetest listsupersededEXACT Coding
An EXACT Coding workflow for Claude Code (arm: subagents). The main context only orchestrates: test list, Red, Green and Refactor each run in their own isolated subagent with a fresh context, and get the file paths and current state from the orchestrator. The test list is limited to base functionality and not cross-checked. Red predicts compilation and runtime failures, and Refactor must attempt an improvement every cycle under the Four Rules of Simple Design and APP mass.
exact-subagents-v2-testlist-fix-ccsubagentsClaude Codetest listtrunkparent: exact-subagents-v1-ccEXACT Coding
A variant of exact-subagents-v1 (arm: subagents) that changes the test list: it covers every rule, example and clarifying question in the specification, with expected values in each description, instead of base functionality only. It also removes the generic project-convention sections (hexagonal architecture, named exports, arrow functions) from the phase subagents. Every phase stays isolated in its own subagent, and the refactoring rules are unchanged.
exact-single-context-v1-ccsingle-contextClaude Codetest listsupersededEXACT Coding
An EXACT Coding workflow for Claude Code (arm: single-context). It starts with a short, inactive test list limited to base functionality, ordered simple to complex and not cross-checked, then works through it one test at a time. Red predicts the compilation failure and then the runtime failure before each test run. Refactor must attempt at least one improvement per cycle, using the Four Rules of Simple Design and APP mass. All four phases are slash commands running in one shared context, without subagents.
exact-single-context-v2-testlist-fix-ccsingle-contextClaude Codetest listtrunkparent: exact-single-context-v1-ccEXACT Coding
A variant of exact-single-context-v1 (arm: single-context) that changes one thing: the test list covers every rule, example and clarifying question in the specification instead of base functionality only. Each test description carries the expected value, and the finished list is reviewed against the spec. The phase commands are reworded and expanded, but the phase structure, the shared context and the refactoring rules are unchanged.
exact-single-context-v2-testlist-fix-ocsingle-contextOpenCodetest listtrunkparent: exact-single-context-v2-testlist-fix-ccEXACT Coding
The OpenCode port of exact-single-context-v2-testlist-fix (arm: single-context). Same method and content as the Claude Code version; only the packaging differs: OpenCode skills and an AGENTS.md instead of slash commands and rules, plain-text markers instead of emoji, and the subagent (task) tool disabled.
exact-single-context-v3-no-subagent-ccsingle-contextClaude Codetest listbranchparent: exact-hybrid-v8-no-end-refactor-ccEXACT Coding
An EXACT Coding workflow for Claude Code (arm: single-context). It starts with a complete, inactive test list covering every rule, example and clarifying question in the specification, not cross-checked against independent dimensions, then runs Red–Green–Refactor one test at a time with failure predictions in Red. Each cycle must attempt a refactoring under the Four Rules of Simple Design; APP mass only breaks ties and never outranks intent. All phases are skills in one shared context, with no subagents and no final whole-codebase refactoring pass.
exact-hybrid-v1-cchybridClaude Codetest listsupersededEXACT Coding
An EXACT Coding workflow for Claude Code (arm: hybrid). It starts with a short, inactive test list that covers base functionality only and leaves out edge cases and advanced features; the list is not cross-checked. Test list, Red (with compile and runtime predictions) and Green run as slash-command skills in one shared main context. Each Refactor runs in an isolated subagent that checks naming first, applies the Four Rules of Simple Design in priority order and compares APP mass before and after.
exact-hybrid-v2-testlist-fix-cchybridClaude Codetest listsupersededparent: exact-hybrid-v1-ccEXACT Coding
A variant of exact-hybrid-v1-cc (arm: hybrid) whose main change is the test list: it is derived from the whole specification instead of base functionality only. Every rule, every example and every clarifying question gets at least one inactive test, with the expected value in its description. It is ordered from single rules to combinations and multi-step scenarios, and it is not cross-checked. In addition, the refactoring subagent loses its generic project-standards section (TypeScript conventions, hexagonal architecture, build commands).
exact-hybrid-v2.4-lab-split-cchybridClaude Codetest listbranchparent: exact-hybrid-v2-testlist-fix-ccEXACT Coding
A variant of exact-hybrid-v2-testlist-fix-cc (arm: hybrid) that moves the lab infrastructure (autonomous-execution mandate, done marker, phase-continuation note) into a separate lab-only rules file and the refactor-subagent prompt contract into its own rules file. The agent-facing method is unchanged.
exact-hybrid-v4-cleaned-cchybridClaude Codetest listtrunkparent: exact-hybrid-v3-with-why-ccEXACT Coding
An EXACT Coding workflow for Claude Code (arm: hybrid). Derived from the hybrid line, it starts with an inactive test list covering every rule, example and clarifying question of the specification; the list is not cross-checked. Test list, Red (with compile and runtime predictions) and Green run as slash-command skills in one shared context. Short "Why" blocks explain why Green stays minimal, why the prediction format matters and why every phase must be delegated. Refactoring runs in an isolated subagent, framed as a standalone refactoring task: naming first, the Four Rules of Simple Design, and APP mass before and after.
exact-hybrid-v4-cleaned-pihybridpitest listtrunkparent: exact-hybrid-v4-cleaned-ccEXACT Coding
The pi port of exact-hybrid-v4-cleaned-cc (arm: hybrid). Test list, Red and Green are pi skill documents that the agent reads and follows in the main context, and Refactor runs in an isolated subagent through a bundled subagent extension. Because pi skill phases are not tool calls, the port has the agent mark each phase with fixed headings in its output. One rule goes beyond packaging: when a newly activated test already passes, the cycle skips Green and Refactor.
exact-hybrid-v4.2-phase-continuation-pihybridpitest listbranchparent: exact-hybrid-v4-cleaned-piEXACT Coding
A variant of exact-hybrid-v4-cleaned-pi (arm: hybrid) that changes one thing: it tells the agent to treat every phase-completion line as a checkpoint, not as the end of its turn. The emphasis is on the step from test list to the first Red, and the run may only end once the work is complete. Method and content are otherwise unchanged.
exact-hybrid-v4-cleaned-ochybridOpenCodetest listtrunkparent: exact-hybrid-v4-cleaned-ccEXACT Coding
The OpenCode port of exact-hybrid-v4-cleaned-cc (arm: hybrid). Same method and content; only the harness packaging differs. Test list, Red and Green are OpenCode skills, and Refactor is an OpenCode subagent with restricted permissions that is called through the task tool.
exact-hybrid-v4.2-phase-continuation-cursorhybridCursortest listbranchparent: exact-hybrid-v4-cleaned-ccEXACT Coding
The Cursor port of exact-hybrid-v4-cleaned-cc (arm: hybrid). Same method and content: test list, Red and Green are Cursor skill documents followed in the main context, and Refactor runs as an isolated Cursor subagent. Beyond packaging, it adds visible text markers for the skill phases and the same phase-continuation instructions as the pi v4.2 variant, so that a finished phase or a returning subagent does not end the turn.
exact-hybrid-v6-lab-split-cchybridClaude Codetest listtrunkparent: exact-hybrid-v5-end-refactor-ccEXACT Coding
An EXACT Coding workflow for Claude Code (arm: hybrid). Derived from the hybrid line, it has a spec-complete inactive test list that is not cross-checked. Test list, Red (with predictions) and Green run as skills in a shared context, and each Refactor runs in an isolated subagent (naming first, the Four Rules of Simple Design, APP mass). After the last cycle, a second isolated end-refactor subagent makes one pass over the whole production code. It works one change at a time, guided by measured smells, cognitive and McCabe complexity and APP mass. Lab infrastructure lives in a separate rules file.
exact-green-refactor-v2-testlist-fix-ccgreen-refactorClaude Codetest listtrunkparent: exact-green-refactor-v1-ccEXACT Coding
An EXACT Coding workflow for Claude Code (arm: green-refactor). Derived from the hybrid line, it starts with an inactive test list covering every rule, example and clarifying question of the specification; the list is not cross-checked. Test list and Red (with compile and runtime predictions) run as skills in the main context. Green and Refactor each run in their own isolated subagent: Green writes the minimal passing code, and Refactor checks naming first, applies the Four Rules of Simple Design and compares APP mass.
EXACT Coding — SOL line
exact-sol-v1-pisolpitest listtrunkEXACT Coding
An EXACT Coding workflow for the pi harness (arm: sol). It starts with an ordered list of inactive tests covering every rule and example in the specification. The list is not cross-checked against independent dimensions. The workflow then goes through the list one test at a time in predictive Red–Green–Refactor cycles, where a valid Red has to fail because the behavior is missing. Refactoring applies only the Four Rules of Simple Design: no domain-boundary trial, no APP. Everything runs in one shared context, without subagents.
exact-sol-v1-ccsolClaude Codetest listtrunkparent: exact-sol-v1-piEXACT Coding
The Claude Code port of exact-sol-v1-pi (arm: sol). It uses the same method and content as the pi version; only the packaging differs: slash commands and rules instead of pi skills.
exact-sol-v1.1-subagent-pisolpitest listbranchparent: exact-sol-v1-piEXACT Coding
A variant of exact-sol-v1-pi (arm: sol) for pi that changes one thing: the Refactor phase runs in an isolated refactoring subagent with a fresh context, while test list, Red and Green stay in the main context. The refactoring contract is unchanged: the Four Rules of Simple Design, one refactoring at a time.
exact-sol-v1.3.2-local-git-control-pisolpitest listbranchparent: exact-sol-v1.3-stack-profile-piEXACT Coding
A pi workflow (arm: sol) derived from exact-sol-v1.3-stack-profile-pi. It is content-identical to that workflow and runs under a different harness condition: the run directory is an isolated local Git repository.
exact-sol-v1.5-tcr-parity-domain-trial-pisolpitest listsupersededparent: exact-tcr-v1.3-domain-boundary-trial-piEXACT Coding
An EXACT Coding workflow for the pi harness (arm: sol), derived from the TCR workflow exact-tcr-v1.3-domain-boundary-trial-pi. It keeps that workflow's complete, inactive test list, which is not cross-checked against independent dimensions, and works through it one test at a time in predictive Red–Green–Refactor cycles. Where TCR commits or reverts each phase, this workflow predicts, checks and narrowly undoes changes instead. Refactoring applies the Four Rules of Simple Design, a domain-responsibility review and a mandatory domain-boundary trial, with no APP. Everything runs in one shared context, without subagents.
exact-sol-v1.5-tcr-parity-domain-trial-ccsolClaude Codetest listsupersededparent: exact-sol-v1.5-tcr-parity-domain-trial-piEXACT Coding
The Claude Code port of exact-sol-v1.5-tcr-parity-domain-trial-pi (arm: sol). It uses the same method and content as the pi version; only the packaging differs: slash commands and rules instead of pi skills.
exact-sol-v1.6-test-list-dimensions-pisolpitest listsupersededparent: exact-sol-v1.5-tcr-parity-domain-trial-piEXACT Coding
A variant of exact-sol-v1.5-tcr-parity-domain-trial-pi (arm: sol) for pi that changes one thing: before the test list counts as complete, it is cross-checked against the specification's independent dimensions (operations, variants, policy attributes, parallel catalogues), and a test is added for every cell that could drift unnoticed. A mechanical Cartesian product of all dimensions is explicitly ruled out.
exact-ptdd-v1-piptddpitest listtrunkparent: exact-sol-v1.6-test-list-dimensions-piEXACT Coding
An EXACT Coding workflow for the pi harness. Arm: Predictive TDD (ptdd). It starts with a complete, inactive test list derived from the specification and cross-checked against its independent dimensions, then works through it one test at a time in predictive Red–Green–Refactor cycles. Refactoring applies the Four Rules of Simple Design plus a mandatory domain-boundary trial. Everything runs in one shared context, without subagents.
exact-ptdd-v1-ccptddClaude Codetest listtrunkparent: exact-ptdd-v1-piEXACT Coding
The Claude Code port of exact-ptdd-v1 (arm: ptdd). Same method and content as the pi version; only the harness packaging differs — slash commands and rules instead of pi skills.
exact-ptdd-v1.1-refactor-subagent-piptddpitest listbranchparent: exact-ptdd-v1-piEXACT Coding
A variant of exact-ptdd-v1 (arm: ptdd) that changes one thing: the Refactor phase runs in an isolated refactoring subagent with a fresh context, while test list, Red and Green stay in the main context. The refactoring contract — Four Rules of Simple Design plus mandatory domain-boundary trial — is unchanged.
exact-ptdd-v1.1-refactor-subagent-ccptddClaude Codetest listbranchparent: exact-ptdd-v1.1-refactor-subagent-piEXACT Coding
The Claude Code port of exact-ptdd-v1.1-refactor-subagent-pi (arm: ptdd). Same method and content; only the packaging differs — the isolated refactoring runs as a Claude Code Task subagent instead of through the pi subagent extension.
exact-ptdd-v1.2-verification-split-piptddpitest listbranchparent: exact-ptdd-v1-piEXACT Coding
A variant of exact-ptdd-v1 (arm: ptdd) for pi that changes one thing: the test list is split into driving tests and a trailing verification group. Before activation, each driving test is checked again and moved to the verification group if an earlier test already covers it. Verification tests are activated only after every driving test is green, each predicted to pass. The dimensions cross-check and the domain-boundary trial are unchanged.
exact-ptdd-v1.2-verification-split-ccptddClaude Codetest listbranchparent: exact-ptdd-v1.2-verification-split-piEXACT Coding
The Claude Code port of exact-ptdd-v1.2-verification-split-pi (arm: ptdd). It uses the same method and content as the pi version; only the packaging differs: slash commands and rules instead of pi skills.
exact-sol-v1.6-test-list-dimensions-ccsolClaude Codetest listsupersededparent: exact-sol-v1.6-test-list-dimensions-piEXACT Coding
The Claude Code port of exact-sol-v1.6-test-list-dimensions-pi (arm: sol). It uses the same method and content as the pi version; only the packaging differs: slash commands and rules instead of pi skills.
exact-sol-v1.6.1-naming-refactor-trial-ccsolClaude Codetest listbranchparent: exact-sol-v1.6-test-list-dimensions-ccEXACT Coding
A variant of exact-sol-v1.6-test-list-dimensions-cc (arm: sol) for Claude Code that changes one thing: every Refactor phase evaluates naming first, then has to try and verify one concrete behavior-preserving refactoring, with helper extraction named as an explicit option. Refactoring stays in the shared context, without a subagent. The Four Rules and the domain-boundary trial are unchanged.
exact-tcr-v1-pitcrpitest listtrunkEXACT Coding
An EXACT Coding workflow for the pi harness (arm: tcr). It starts with a complete, inactive test list derived from the specification and not cross-checked against independent dimensions, and commits that list. It then works through one behavior at a time in Red–Green–Refactor cycles, committing or reverting every phase and every single refactoring with native Git. Refactoring applies only the Four Rules of Simple Design, without a domain-boundary trial. Everything runs in one shared context, without subagents.