Martin Fowler published a fascinating report from a February 2026 retreat where senior engineering practitioners from major tech companies gathered to discuss how AI is reshaping software development. It’s dense, so here’s what stood out to me.

Where Does the Rigor Go?

The biggest question of the retreat: if AI writes the code, where does the engineering discipline move? The answer is — it doesn’t disappear, it migrates:

  • Upstream to specs — Bad specs produce bad code at scale. Teams are adopting structured formats like EARS, state machines, and decision tables because traditional user stories are too vague for AI agents.
  • Into test suites — TDD produces dramatically better results from AI coding agents. Tests become deterministic validation for non-deterministic generation. Several practitioners now treat generated code as expendable — if the tests pass, the code is acceptable.
  • Into type systems and constraints — Instead of reviewing code after generation, make incorrect code unrepresentable through strong types and formal constraints.
  • Into risk mapping — Not all code carries the same risk. The new discipline is asking “what is the blast radius if this code is wrong?” and scaling verification proportionally.

“I’ve gotten better results from TDD and agent coding than I’ve ever gotten anywhere else, because it stops a particular mental error where the agent writes a test that verifies the broken behavior.”

The Middle Loop

This is probably the freshest concept in the report. We’ve always talked about the inner loop (write, test, debug) and the outer loop (CI/CD, deploy, operate). The retreat identified a middle loop — supervisory engineering work that involves directing, evaluating and fixing AI agent output.

People excelling at this tend to think in delegation and orchestration rather than direct implementation, have strong mental models of system architecture, and can assess output quality without reading every line.

The career implication is real: many developers were hired to translate tickets into working code. That work is disappearing. The parallel they drew was computer graphics — in 1992 engineers hand-coded polygon rendering. Two years later that was in hardware and the job became animation and lighting. Same dynamic playing out now.

Agent Topologies

Conway’s Law didn’t retire — it got more complicated. Unlike humans, agents can be duplicated across teams instantly. A specialized database agent can exist on every team without the centralization bottleneck of a single human specialist.

But there are problems:

  • Speed mismatch — Teams clear backlogs in days with AI tools, then hit walls of cross-team dependencies and human-speed decision-making. The bottleneck shifts from engineering capacity to everything else.
  • Agent drift — Agents learning from context diverge over time, even from identical configurations.
  • Decision fatigue — Agents produce work faster than leaders can review and approve it. Middle managers become approval bottlenecks.

The Productivity/Experience Paradox

Developer productivity and developer experience are decoupling. Organizations can get more output through AI even when developers report lower satisfaction and higher cognitive load.

One practitioner offered a sharp reframe: stop calling it “developer experience” and call it “agent experience” instead. Wallets open faster for investments that help agents perform well, and the overlap with what helps humans perform well is nearly complete.

Security Is Dangerously Behind

The security session had low attendance — which perfectly reflects the industry pattern. The most vivid example: granting an agent email access enables password resets and full account takeover. The recommendation was blunt — platform engineering should make safe behavior easy and unsafe behavior hard. Don’t rely on individual developers making security-conscious choices when configuring agent access.

Juniors Are More Valuable, Not Less

This one surprised me. The retreat pushed back on the “AI kills junior roles” narrative. Juniors are more profitable than ever — AI tools get them past the initial net-negative phase faster, and they’re better at AI tools than seniors because they never developed the habits that slow adoption.

The real concern is mid-level engineers who came up during the hiring boom and may lack the fundamentals to thrive in the new environment.

My Take

The report is worth reading in full, but the two things that stuck with me most:

  1. TDD as prompt engineering — framing test suites as the primary artifact and generated code as disposable is a genuinely useful mental model.
  2. The middle loop — we don’t have career ladders, job titles, or training programs for the supervisory engineering work that’s becoming the actual job. That gap is going to hurt.

The retreat didn’t produce a roadmap. It produced a shared understanding that the map is being redrawn. That honesty is more useful than another hype-filled prediction.