Lights Out · Part 3 / 3

Lights Out, Part 3: The Hill Climb

September 21, 2026 · 9 min read

A lights-out factory with no feedback is a flat loop. It repeats but never improves. Part 1 named the state; Part 2 earned the trust to run unattended; Part 3 answers the improvement question. The whole game is choosing a reward signal that cannot corrupt the system it steers. Search demand gaps select the next batch of topics; a noise floor keeps small samples from steering; the voice spec is constitutional, engagement never gets a vote on how anything is written, only on what gets written next.

AI AgentsAutomationReward SignalsPublishing Pipeline
Lights Out · Part 2 / 3

Lights Out, Part 2: Earning Confidence

September 17, 2026 · 9 min read

You trust an unattended pipeline the way you trust a test suite: through named regressions and fail-closed design, not through watching it. The 2026-05 incident on this blog's own pipeline (a post merged to main as a base64 blob, two weeks of broken builds, a double-publish before the fault surfaced) is the scar this post carries. The fix was not more human review. The fix was deterministic scripts with structural validation gates, atomic all-or-nothing pushes, tests that pin each incident by name, and a veto window replacing the approval queue.

AI AgentsAutomationReliabilityTest Discipline
Lights Out · Part 1 / 3

Lights Out, Part 1: The Flat Loop

September 14, 2026 · 8 min read

This blog's own publishing pipeline is a lights-out factory. No human sits in the merge loop on any weekday. The last human gate was not deleted; it was replaced by machine-checkable guardrails: an allowlist on what a bot PR may touch, triggers that fail closed on any schema violation, and a veto window on the posts themselves rather than an approval queue in front of them. Before the rebuild, proposal PRs stacked for weeks while adding zero editorial value; the gate was still blocking merges it had already stopped reviewing.

AI AgentsAutomationCI/CDPublishing Pipeline

The Agent's TODO Is a Signed Confession, Not a Marker

September 10, 2026 · 8 min read

A TODO comment used to be a note-to-self and the sprint usually returned. Two independent 2026 studies of AI-authored self-admitted technical debt land the same finding: agents write more detailed TODOs than humans, in the same categories, at generation speed. The receipt is filed. The debt keeps compounding. The discipline move is to treat an agent-authored TODO as an unresolved acceptance criterion in the same PR it appeared in.

AI AgentsTechnical DebtCode ReviewWorkflow

Harness Engineering Is the Test Suite, Renamed

September 7, 2026 · 8 min read

The industry named a new discipline in early 2026 and packaged it as harness engineering. Read the load-bearing parts of every taxonomy that shipped and the same shape repeats: CI gates, test-suite feedback, deterministic verification loops, sandbox permissions that fail closed. The disciplined test suite is the load-bearing layer inside the harness, and calling the whole stack one new discipline blurs which piece is doing the correctness work.

AI AgentsTest DisciplineHarness EngineeringVerification

The Bounded Context Is the Scope the Agent Actually Needs

August 27, 2026 · 9 min read

The industry gave the coding agent the whole repo as its working scope and is discovering that agents do the most damage where they are most helpful: making things consistent across boundaries that were not supposed to be consistent. Bounded contexts are not a design pattern for humans anymore. They are the scoping primitive that keeps the vocabulary the team owns from being consolidated by the tool the team hired.

AI AgentsDomain-Driven DesignVocabularySoftware Architecture

The Contract Test Is the Only Witness the Agent Cannot Author

August 24, 2026 · 9 min read

A test the agent wrote against code the same agent wrote shares the agent's blind spot: a misunderstanding in the implementation becomes a matching misunderstanding in the test, the bar goes green, and the bug ships certified. Consumer-driven contract tests are the only category where a second team publishes the assertion the first team has to satisfy. That separation of authorship is exactly what tamper-resistant test design demanded, applied at the integration seam.

TDDAI AgentsContract TestingTest Design

AI Reviewing AI Is Not Review

August 20, 2026 · 9 min read

Agent PR volume is up sharply and the industry response has been to deploy code-review agents to catch up. The 2026 MSR study measured what that response actually produces: 60.2% of CRA-only closed PRs sit in the 0 to 30 percent signal-ratio range. Adding a review agent to review the coding agent does not solve the volume problem; it amplifies noise the human reviewer then has to filter.

AI AgentsCode ReviewSoftware CraftSignal to Noise

Cohesion Is the Coverage of the Agent Era

August 17, 2026 · 9 min read

Agent-generated codebases pass every structural-modularity metric while fragmenting the domain concept the team was trying to encode. Coverage measured whether a line ran. Mutation score measured whether an assertion pinned behavior. Cohesion is the next axis, and it measures whether the codebase's concepts are traversable end-to-end.

TDDAI AgentsSoftware DesignDomain Modeling

The Coordinated Rename Is the Agent's Most Dangerous Refactor

August 13, 2026 · 9 min read

Multi-agent rename tooling rewrites two hundred files in ten seconds because it noticed the drift. Half the time the drift was a load-bearing distinction the team encoded on purpose. Vocabulary curation is a real-time review surface now, and senior includes refusing changes that would be technically more consistent because the domain has two concepts the agent has no way to see.

VocabularyAI AgentsDomain ModelingCode Review

Test Deletion Is a Privileged Operation

August 10, 2026 · 10 min read

The cheapest way for an agent to make a failing test pass is to delete it. That is logical for the agent and catastrophic for the codebase. Tests are append-only by default. Deletion needs a human author, a separate commit, and a separate review.

TDDAI AgentsTest DesignCode Review

Refactor Was Always Where Compounding Lived

August 6, 2026 · 10 min read

Red and green were the visible two thirds of TDD. Refactor was the optional polish. Codebases that compound did the refactor pass; codebases that accrete did not. Agents skip refactor by default because it has no green-bar reward, and a year of skipped refactors is how a codebase loses its shape.

TDDAI AgentsRefactoringCode Quality

The Instruction File Is Not the Discipline

August 3, 2026 · 9 min read

Teams that want their agent to do TDD reach for the instruction file. The TDAD paper measured this directly: adding a 'do TDD' instruction raised regressions by nearly two-thirds. Contextual test discovery cut them by seventy percent. The instruction is theatre. The codebase's test surface is the discipline.

TDDAI AgentsInstruction FilesTest Design

Spec-Driven Development Is the Prose-Spec Drift Trap, Reborn

July 30, 2026 · 10 min read

Spec-Driven Development positions a separate prose document as the source of truth for what the system should do. Four generations of prose specs have drifted from the code, and SDD will drift too. Prose captures intent. Tests enforce claims. Production is the verdict.

TDDAI AgentsSpec-Driven DevelopmentBDD

Tamper-Resistant Test Design Is What the Suite Now Owes the Codebase

July 27, 2026 · 15 min read

Tests were a contract the team made with itself. Agents made the suite an attack surface. Tamper-resistant test design is what the suite now owes the codebase: expensive to spoof, redundantly verified, partially hidden, and impossible to delete without a separate review.

TDDAI AgentsTest DesignSecurity

A Flaky Test Is a Corrupted Reward Signal

July 23, 2026 · 13 min read

A flaky test is an annoyance to a human and a catastrophe to an agent. The human re-runs it and moves on. The agent reads the random red as a defect and changes correct code. Determinism is the precondition for letting an agent close the loop unattended.

TDDAI AgentsTest DesignContinuous Integration

The Test Pyramid Was an Economic Argument

July 20, 2026 · 12 min read

The test pyramid was not a quality law. It was a cost structure: unit tests were cheap, integration tests were expensive, so you wrote many of the first and few of the second. Agents collapsed the cost of writing tests at every level, and the cheapest test that still tells the truth is the one that pins a seam the agent cannot fake.

TDDAI AgentsTest DesignSoftware Architecture

Agents Pattern-Match Your Test Smells

July 16, 2026 · 14 min read

Test smells used to drift in at typing speed. Agents reproduce them at generation speed because they sample whatever is already in the suite. The smells in your codebase are now the smells in your roadmap.

TDDAI AgentsTest SmellsCode Review
Vocabulary Is the Product · Part 3 / 3

Product Literacy Is the New Core Engineering Skill

July 13, 2026 · 15 min read

Engineering treated product literacy as a 'nice to have', useful but not core. With agents handling translation from intent to syntax, the engineer's value lives almost entirely in the translation from business reality to correctly-named domain model. Product literacy is the part that didn't get automated.

AI AgentsSoftware CraftProductEngineering Career
Vocabulary Is the Product · Part 2 / 3

Agents Amplify Whatever Vocabulary They Find

July 9, 2026 · 15 min read

Agents do not bring vocabulary to your codebase. They mirror what's already there. Strong vocabulary gets agent contributions that read like the team. Weak vocabulary gets faster mediocrity. The work you did for craft reasons just became leverage.

AI AgentsTDDSoftware CraftTest Design
Vocabulary Is the Product · Part 1 / 3

The Hidden Output of TDD Was Never Code

July 6, 2026 · 14 min read

The visible artifact of TDD is a passing test suite. The actual artifact, the one that compounded value over the life of the codebase, was the vocabulary the team built while writing it. The dictionary, not the regression net.

TDDDomain-Driven DesignSoftware CraftTest Design

Evals Are Tests Wearing a Lab Coat

June 29, 2026 · 11 min read

An eval is a test: a named scenario, an assertion, a verdict. The eval-tooling wave rebuilt the BDD coordination tax as golden datasets owned by a separate role. The eval suite should be the test suite, in domain language, with builders.

TDDAI AgentsTest DesignSoftware Delivery

Examples Pin Intent. Properties Pin the Invariants.

June 22, 2026 · 16 min read

Example-based tests anchor scenarios in the team's vocabulary. Property-based tests anchor invariants across the input space. The agent needs both axes, and most suites only carry one.

TDDAI AgentsProperty-Based TestingTest Design

Characterization Tests Are How Agents Enter Legacy Code

June 15, 2026 · 11 min read

Most code an agent is asked to change is legacy: large, under-tested, its behavior known only by what production does. An agent changing untested code is changing code with no specification. Characterization tests pin what the code does before anyone decides what it should do, and they are the on-ramp that makes the untested parts of a codebase safe to hand to an agent.

TDDAI AgentsLegacy CodeTest Design

World-Building Is the Test Discipline Agents Need

June 8, 2026 · 11 min read

A scenario factory is not setup convenience. It is a world-modeling language, and the layered grammar of object mothers, builders, and factories is the composition primitive agents recombine. Teams that hand-assemble setup hand agents nothing to build worlds from.

TDDTest DesignAI AgentsSoftware Craft
The PR Is Eating Itself · Part 2 / 2

What 'Senior' Means When Typing Is Free

June 1, 2026 · 16 min read

The traits the industry credentialed as senior, typing fluency and framework recall and syntax intuition, were proxies. The actual senior skill was always naming the right problem and shaping the seams that make it solvable. Agents made the proxies free; the actual skill is now visible.

AI AgentsSoftware CraftEngineering CareerTeam Topologies

Coverage Was a Proxy. The Proxy Just Failed.

May 25, 2026 · 16 min read

Coverage measured execution, not verification. Agent-generated tests pass coverage gates while writing assertions that pass even when behavior breaks. Mutation score is the metric coverage was always pretending to be.

TDDAI AgentsTest DesignMutation Testing
The PR Is Eating Itself · Part 1 / 2

Where the Review Point Moved

May 18, 2026 · 14 min read

Code review was always a weak proxy for design review. When agents write the implementation, the review surface migrates upstream to test names, builder APIs, and contract assertions. The diff is downstream of all three.

Code ReviewAI AgentsTDDSoftware Delivery

Just-in-Time Tests Are What You Get When You Gave Up

May 11, 2026 · 14 min read

Disposable tests catch this PR's regression and contribute zero to the next one. The persistent suite is a vocabulary, a contract layer, and a 10-year asset. JIT testing is a hospice plan for teams whose suites stopped compounding.

TDDAI AgentsTest DesignSoftware Craft

Agents Should Do TDD: For the Same Reason You Should Have

April 26, 2026 · 15 min read

TDD's value was never that a human ran the loop. The value was the loop itself: a constrained search procedure that converges on code that is correct, named for intent, and shaped to change. Strip the human out and the discipline still works for the same reasons.

TDDAI AgentsSoftware CraftTest Design
TDD in the Agentic Era · Part 3 / 3

The Bar for TDD Just Moved

April 14, 2026 · 9 min read

Agentic coding changes what 'good tests' means. The new floor is scenario-rich, builder-driven, domain-typed tests authored by product-thinking developers, because that's the artifact agents actually compose against.

TDDAI AgentsSoftware CraftTest Design
TDD in the Agentic Era · Part 2 / 3

BDD Was a Coordination Tax. AI Just Repriced It

April 7, 2026 · 11 min read

Gherkin was never really a test format. It was a coordination protocol between specialized roles. In the AI era, where roles compress and translation is cheap, the protocol becomes friction instead of leverage.

BDDAITeam TopologiesSoftware Delivery
TDD in the Agentic Era · Part 1 / 3

TDD Already Does BDD, Without the Gherkin

March 24, 2026 · 8 min read

BDD wasn't a discovery. It was a rebrand of what disciplined TDD was already doing. Test data builders, factory hierarchies, and mock-driven collaboration tests are the scenarios, and they evolve alongside the code instead of rotting beside it.

TDDBDDTest DesignSoftware Craft

Katas Are Rehearsal, Not Performance

February 28, 2026 · 3 min read

You don't practice TDD on production code. You practice on katas and bring the muscle memory to production. The gap between knowing TDD and doing TDD is reps.

TDDKatasPracticeSoftware Craft

Your Test Suite Is Your API for Agents

February 15, 2026 · 3 min read

Documentation lies. Wikis rot. READMEs drift. Your test suite is the only specification that stays current, and it's the interface AI agents actually use.

TDDAI AgentsSoftware ArchitectureAutomation

AI Agents Need Test Suites, Not Code Reviewers

February 1, 2026 · 3 min read

Autonomous AI agents can plan, implement, and deliver code. But without automated verification, you're just producing unreviewed changes faster. TDD provides the feedback loop agents actually need.

TDDAI AgentsAutomationDevOps

TDD Is Scaffolding for AI, Not a Speed Bump

January 1, 2026 · 3 min read

AI generates code fast. But speed without verification is just higher-velocity guessing. TDD provides the specification layer that makes AI-generated code trustworthy.

TDDAIAutomationSoftware Delivery