Future of Software Engineering — Retreat Key Takeaways

Martin Fowler shared today on his blog page about the Thoughtworks Future of Software Development Retreat held in February 2026. As I read the details, one document captured my attention:

• tw_future_of_software_development_retreat_key_takeaways.pdf

I felt like, this is a good state-of-the-union for the current AI driven software development. I thought sharing a summerized view would be benefitial for everyone.

1. Rigor Isn't Gone — It Moved

Engineering discipline hasn't disappeared; it migrated upstream to specs, into test suites, type systems, risk mapping, and continuous comprehension. TDD is now the strongest form of prompt engineering — tests written before code prevent agents from cheating by validating broken behavior. Spec quality is now the highest-leverage artifact.

2. There's a New "Middle Loop" Nobody Has Named Yet

We now operate in three loops — inner (coding), outer (CI/CD), and a newly forming middle loop: directing, evaluating, and correcting AI agent output. The engineers thriving here think in delegation and orchestration, have strong architectural mental models, and can assess output quality without reading every line. Career ladders don't recognize this yet — and that's a problem.

3. Conway's Law Now Applies to Agents Too

Agent topology mirrors team topology. Agents can be cloned across teams instantly, but they drift over time, accumulating different patterns per context. Speed mismatches are real — agents clear backlogs in days but then hit human-speed bottlenecks (architecture reviews, approvals). Decision fatigue is the new delivery constraint.

4. Security Is Dangerously Underdeveloped

This received the lowest session attendance — which is itself the warning sign. Giving an agent email access alone is enough for full account takeover. Platform engineering must enforce secure defaults by design, not rely on developers making safe choices individually. AI-speed attacks demand AI-speed defenses.

5. Self-Healing Systems Are Still Far Off

The vision of agents autonomously resolving incidents is real — but the prerequisites aren't met. Most orgs lack: a full change ledger, agent identity/permission controls, and well-defined fitness functions. The hardest problem is latent knowledge — senior engineers carry decades of pattern-matching in their heads that's almost never documented. Building an "agent subconscious" from years of post-mortems is the path forward.

6. Developer Productivity and Developer Experience Are Decoupling

Organizations can get more output from AI tools even when developers report lower satisfaction and higher cognitive load. This weakens the business case for investing in developer experience — unless we reframe it as "agent experience." (Conveniently, the conditions that help agents perform well largely overlap with those that help humans perform well.)

7. Junior Devs Are More Valuable, Not Less

AI gets juniors past the initial net-negative phase faster. They're better at adopting AI tools than seniors. The real risk is mid-level engineers who may lack the fundamentals to thrive — no one has solved retraining this cohort yet. Staff engineers, meanwhile, are most impactful as friction killers, not just deep technical contributors.

8. PM and Developer Roles Are Converging

Nobody can clearly define what PMs will do in an AI-first world. Some orgs are training PMs in Markdown and developer tooling. Others see roles diverging further. What's clear: AI is exposing pre-existing dysfunctions in the PM-developer relationship, not creating new ones.

9. Knowledge Graphs & Semantic Layers Are Having a Moment

Decades-old technologies are suddenly critical as the grounding layer for domain-aware agents. One example: a large telecom captured its entire domain ontology in ~286 concepts. LLMs can auto-generate event storming artifacts from legacy code, compressing weeks of discovery into days.

10. Agile Is Evolving, Not Dying

Sprint cadences are compressing. XP practices (pair programming, ensemble development) are being rediscovered. The real threat is governance — faster teams just hit the same approval walls sooner. Also flagged as a regression: AI is enabling large batch releases again, reversing a decade of DORA research on deployment stability.

Open Questions Left Unanswered

• How do engineers find meaning when code-writing is no longer the job?
• Does faster agent output mean we need fewer (or differently-skilled) middle managers?
• Can test suites + constraints ever fully replace human code review?
• Are we accumulating cognitive debt faster than we realize?
• How do we govern systems where agents move faster than humans can decide?