The Problem
Before this existed, our AI-assisted TDD workflow ran on a single 815-line agent file that loaded in full for every session, whether the task was a controller test or a two-line config fix. Nothing about a session persisted past its end. A lesson learned debugging a flaky repository test on Monday was gone by Wednesday, and the next engineer, or the same one on a different task, paid the discovery cost again. I had already lived through an earlier, more manual version of this problem myself (a companion essay, From Copy-Paste to Context Engineering, covers how that personal workflow evolved), and the team-scale version had the same shape: AI assistance was real, but it forgot everything, and it loaded everything, regardless of what the task needed.
The fix could not just be better prompts. It needed to be infrastructure: a way to load only the context a task needed, and a way for what an agent learned in one session to outlive it without turning into a pile of stale notes nobody trusted.
The Approach
What shipped is a Claude Code component platform, forty-seven skills and nineteen agents, distributed to the team through a 514-line symlink installer so every engineer’s local configuration stays synced to the same source of truth.
The core is a closed loop. A context loader reads only what a task’s layer needs, a layer skill does the actual work, and a retrospective skill writes what was learned back to a dated memory store before the session ends. The next session’s loader reads that store first. The memory store is budgeted, not unbounded. A hot ring buffer holds the five most recent retrospectives per layer, a pattern only gets promoted into durable reference material once it has recurred three or more times, and everything outside that window is deliberately forgotten. That is a stated design choice, not data loss: an unbounded log is not memory, it is a landfill nobody has time to read.
The agent itself went through a re-architecture worth explaining. The original tdd agent was 815 lines, always loaded in full. Version two shipped at 216 lines, roughly a 3.8x reduction, by lazily invoking layer skills on demand instead of inlining everything up front. It has since grown back to around 277 lines, and that growth has a specific cause: a teammate’s review on a later merge request flagged that the platform’s two entry points, a subagent and a main-session command, could drift out of sync silently. I encoded that finding as a standing sync contract rather than trusting memory to catch it next time. A review made the design better, and I built the fix into the structure instead of into a habit.
Scope discipline mattered as much as what got built. A design review before any of this shipped considered thirteen proposed skills and rejected eight of them as the wrong unit of reuse. The five hooks that gate commits and reviews are mostly not mine: a teammate built the content-addressed pre-commit gate and three others; I built one, a hook that validates infrastructure commands before they run, and I own the platform those hooks run inside.
Results
Two-thirds of this is mine: 49 of the platform’s 77 commits on the main branch, working heavily AI-paired throughout with the same kind of tooling this platform produces. My commits carry AI co-author trailers end to end, and I say so on purpose, as engineering discipline, not as a caveat to bury. The rest is split across several teammates, one of whose review changed the design outright, which is the adoption story I want told here, not a solo-build one.
The closed loop is not hypothetical. The memory store holds sixty dated retrospectives written between March and July 2026 across seven different production services, proof the loop ran on real work instead of staying a demo. The clearest single proof case was a security-critical service rewrite: after a stalled attempt to hand-converge old code, I switched to a planned, agent-executed sequence built on a characterization-test safety net, and the rewrite landed in a single day.
My own shipped-commit volume across every repository I touch rose from roughly twenty-three a month in 2024 to roughly two hundred seventy a month by mid-2026, and the inflection point lines up with the month version two of the agent landed. I want to be precise about what that is: a correlation, not a measurement. The set of repositories I was active in was also growing over the same stretch, and I have not isolated this platform’s effect from everything else that changed. What did not happen: a parallel personas system I prototyped stayed on its own branch and never merged, R&D that did not clear the bar for the rest of the team to depend on. Context is an asset; maintain it like code.