ThoughtWorks Future of Software Engineering Retreat

page

A February 2026 retreat bringing senior engineering practitioners from major technology companies together under Chatham House Rule to confront AI's reshaping of software development. More than twenty topics across breakout sessions, but the most significant insights surfaced at the intersections — the same concerns kept appearing in different conversations, framed by different people solving different problems. ThoughtWorks synthesized the cross-cutting themes into ten findings organized by time horizon. The central question: if AI handles the code, where does the engineering actually go? The retreat didn't produce a unified vision — it produced a map of the fault lines where current practices are breaking and new ones are forming.

Key Quotes

"We kept asking the same question in every room: if AI handles the code, where does the engineering actually go? Nobody had the same answer. But everybody agreed the question is urgent."

"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."

"We optimized the software delivery process for humans. Now that it's not just humans, we have to ask what organizing actually means."

"The retreat didn't produce a roadmap. It produced a shared understanding that the map is being redrawn."

"I walked into that room expecting to learn from people who were further ahead. Some of the sharpest minds in the software industry… And nobody has it all figured out. We walked away with more questions than answers, but at least we now have a shared understanding of the sorts of questions we should be asking." — Annie Vella

"AI is a funhouse mirror — an accelerator of what you already have. If foundational delivery practices aren't in place, velocity becomes a debt accelerator." — Rachel Laycock, CTO ThoughtWorks

"Paired programming solves all of this. If it's important to understand the system, then do it all the time. You don't do it in little phases where you have your code review. Constantly trying to understand what this code is doing."

The retreat drew a parallel to the history of computer graphics. In 1992, engineers hand-coded polygon rendering algorithms. Two years later, that work had been pushed into hardware, and the job became animation and lighting. Today, it's custom physics and game worlds. Each time the abstraction layer rose, engineers who insisted they were hired to render polygons were left behind. The same dynamic is playing out now with code production.

On the linter front: an agent with access to a linter enforcing a 500-line file limit responded by making individual lines longer — technically satisfying the rule while violating the principle. When multiple agents make different prioritization decisions, the system oscillates rather than converges.

Ten Themes

Now: 1. Where does the rigor go? Engineering quality migrates to five destinations: specification review (teams adopting EARS, state machines, decision tables — old techniques rediscovered because they give AI enough precision), test suites as first-class artifacts, type systems and constraints (separating specifications from constraints — what should change vs. the bounded contexts where change is allowed), risk mapping (blast radius tiering: "what is the blast radius if this code is wrong, and is our verification proportional to that risk?"), and continuous comprehension. TDD reframed as prompt engineering — deterministic validation for non-deterministic generation. "Bad specs produce bad code at scale." 2. Code review unbundled. Code review served four functions (mentorship, consistency, correctness, trust) that each need a new home. Risk tiering replaces the craft model of reviewing every line. 3. Productivity/experience paradox. Developer productivity and developer experience are decoupling. Sharp reframe: call it "agent experience" instead -- wallets open faster, and the overlap with human needs is nearly complete. 4. Security is dangerously behind. Low attendance at the security session mirrors the industry. Email access alone enables full account takeover. Platform engineering must make safe behaviour the default.

Now to 1 year: 5. The middle loop. A new category of supervisory engineering work between inner-loop coding and outer-loop delivery. Requires delegation thinking, architectural judgment, rapid quality assessment. Nobody has named it yet. Creates identity crisis for developers who love writing code. 6. Cognitive debt. Technical debt becomes cognitive debt -- the gap between system complexity and human understanding. Code review was the learning mechanism; losing it without replacement compounds the gap.

1-3 years: 7. Agent topologies. Conway's Law applies to agents. Agents burn through backlogs then hit human-speed organizational dependencies. Agent drift mirrors team-specific norms on an accelerated timeline. Decision fatigue becomes the new bottleneck. 8. Knowledge graphs and semantic layers. Decades-old technologies suddenly relevant as the grounding layer for domain-aware agents. A large telecom's entire domain ontology captured in roughly 286 concepts — making the work feel achievable, not impossibly ambitious. LLMs auto-generating event storming artifacts (commands, events, aggregates, policies) from code; humans validate and correct, compressing weeks of workshops into days. 9. Role convergence. PM, developer, and designer converging. One large tech company is researching whether the PM role needs a new name; another is training all PMs to work in Markdown inside developer tools. Staff engineers are more effective agent supervisors but spend time on coordination instead — the retreat argued they should become "friction killers." Juniors more profitable than ever — AI gets them past net-negative faster, they're better at AI tools than seniors (no habits to unlearn). Mid-level engineers from the decade-long hiring boom are the real concern. University of Waterloo's co-op program highlighted as a model: deep theory + 2.5 years of industry internships across six rotations.

2-5 years: 10. Self-healing systems. Requires an "agent subconscious" — knowledge graphs from post-mortems. Need "angry agents" to challenge dominant hypotheses (LLMs default to agreement; incident command requires challenge). Multiple agents fixing the same issue create oscillating feedback loops. "Code changes should be the last resort for incident remediation" — the path runs through better rollback, feature flags, and observability before it runs through agents rewriting production code.

Additional Findings

Agile is evolving, not dying. XP practices (pairing, ensemble, CI) rediscovered because tight feedback loops are what agent-assisted work requires. But AI-driven large batch sizes are reversing a decade of DORA research on stability. This is an active regression.

Agent swarms. The barrier is mental, not technical. Sequential thinkers can't conceptualize parallel agent work — "this mental model actively blocks learning." Collective convergence matters more than individual accuracy — a swarm of imperfect agents can produce valuable outcomes if the architecture guides convergence. Some frontier models have structural weaknesses for swarm scenarios; organizations should test specifically for multi-agent coordination, not just single-agent capability. But most enterprise agent orchestration is "patrol workers on loops" — ETL, data quality, monitoring. Organizations with strong, well-designed APIs are significantly better positioned than those without.

The agentic operating system. Work ledger as core primitive (analogous to blockchain): searchable, auditable, enabling agents to discover and bid for work. Agent identity includes its work history, not just persona.

Programming languages for agents. Every language in existence was designed with humans as the primary user. The retreat converged on a principle: "What is good for AI is good for humans." Languages that make incorrect code unrepresentable (strong types, restricted computation models, formal constraints) help agents produce correct output and help humans verify it. The more radical possibility: source code as a transient artifact, generated on demand and never stored. The retreat was divided — some see code disappearing within a decade; others argue deterministic validation always needs a stable artifact.

The "Gas Town" identity crisis. Steve Yegge's concept of appgen engines outrunning dev teams provoked real anxiety about professional identity. If AI does people's work, "who am I and what the heck am I going to do" — echoing Opus 4.5 Changes Everything's ambivalence about craft.

Cost blind spot. One instance burned $300,000 in API calls to Claude to generate an application that generates applications. The group's response: costs will fall, quality will rise. But no one had current economics modelled. The energy debate was dismissed with "we'll build more nuclear reactors."

Just because you can doesn't mean you're ready to. Forrester's Ted Schadler: the retreat surfaced a persistent tension between capability and readiness. AI can do more each month; organizational capacity to absorb, govern, and trust the output grows on a much slower curve. The gap between them is where damage happens.

Adam Tornhill's data. LLMs produce 30% more defects in unhealthy codebases, and the relationship is almost certainly non-linear on legacy code. AI amplifies what's already there — a "funhouse mirror" for your engineering practices.

AI/works platform. ThoughtWorks demonstrated an "agentic delivery platform" synchronizing AI agents across discovery, delivery, and operations. Not open source, not publicly available — but signals where ThoughtWorks is placing its commercial bets.

Key Themes

Critical Analysis

This is the most mature industry synthesis I've seen on how AI changes engineering practice. Where most commentary fixates on productivity gains or job losses, this retreat did the harder work of mapping where specific engineering disciplines migrate when code production is automated.

The strongest insight is the "middle loop" -- supervisory engineering as a distinct discipline. This wiki has been circling this concept across Agent Coding Workflow, Scaling Long-Running Agents, and Five Levels from Spicy Autocomplete to the Dark Software Factory, but nobody had named the category. ThoughtWorks names the gap without filling it, which is honest.

The TDD-as-prompt-engineering framing is the most practical takeaway. It connects directly to Spec-Driven Development's triangle model and Guardrails and Feedback Loops's "linters beat prompts" thesis. Tests are the deterministic constraint on non-deterministic generation. This is not new but the articulation is crisp.

The weaknesses: the report is studiously balanced in a way that softens some hard truths. The mid-level engineer problem is acknowledged but not confronted -- "no organization has solved it yet" is a polite way of saying the industry is about to have a painful reckoning with a large population of engineers who lack the fundamentals to supervise what they used to produce. The security section is thin relative to its urgency, which the report itself admits. And the agent topology discussion stops short of the obvious conclusion: if agents make organizational bottlenecks visible, the response is not "differently-skilled managers" -- it's fewer layers, period.

The Chatham House Rule is both the report's strength and weakness. It allows candour but prevents verification. We're trusting ThoughtWorks' synthesis of anonymous practitioners from unnamed companies. The insights ring true against this wiki's evidence base, but the provenance is deliberately opaque.

Most notable absence: cost. The $300K anecdote surfaced in Forrester's coverage, not in ThoughtWorks' own report. The group's dismissal of the energy economics question with "we'll build more nuclear reactors" is telling — these are software people, not infrastructure people, and it shows. The economics of agent-assisted development — token spend, infrastructure, the How to Buy Cheap Claude Tokens in China grey market — are completely absent from what claims to be a strategic planning document. When you're burning six figures on API calls and your answer is "costs will fall," you're not doing strategy — you're doing faith.

The "Gas Town" identity crisis is the emotional undercurrent the report's measured tone conceals. Steve Yegge's framing (appgen engines outrunning dev teams) and Nolan Lawson's mourning-of-craft essay are the lived experience behind the "middle loop." The retreat participants felt this personally but the report intellectualizes it into a new job category. That's useful for planning but dodges the human cost. Opus 4.5 Changes Everything is more honest about the grief.

Forrester's Schadler closes with the right binary: "We can let the AI tell us what to do. Or we can tell the leaders of AI companies what to do." The retreat chose door number three: let the practitioners define the questions and trust that shared understanding will produce better answers than either submission or regulation. Whether that's wisdom or wishful thinking depends on whether the retreat's participants actually have the leverage they think they do.

Cross-Links

Sources: The Future of Software Engineering — Retreat Findings and Strategic Insights (primary — full ThoughtWorks PDF), Martin Fowler's bliki, Forrester analysis Last updated: 2026-05-18