In the first edition of this newsletter, reflecting on the conversations at the first Future of Software Engineering Retreat in Utah, I argued that AI doesn't eliminate engineering rigor, it relocates it. As more code is generated by AI, rigor moves upstream into specifications, architecture, testing and governance. Engineering becomes less about implementation and more about judgment.
Four months later, I once again met with industry leaders at our European Future of Software Engineering Retreat in Engelberg, Switzerland. Many of the themes from Utah still hold. But what struck me this time was that the conversation had changed.
In February, we were debating possibilities. By June, people were sharing lived experiences. The industry's early experiments have become production systems. AI-first software delivery is no longer a hypothesis. It's becoming operational reality. That changes the questions we need to ask.
This edition is about what happens when coding is no longer the constraint around which software engineering is organized. What becomes scarce? What becomes valuable? And what do leaders need to redesign in response?
These are the questions that dominated our discussions in Switzerland, and they're the questions I explore below.
Rebalancing the system after the constraints have moved
In February we were still talking about rigor as something that moves within the software development lifecycle. The frame that emerged in Switzerland was bigger than that. AI hasn't just relocated rigor, it has dramatically reduced the constraint that shaped almost every aspect of how we build software.
For most of the industry's history, we optimized around one dominant bottleneck: writing code. Our processes, organization structures, hiring models and success metrics were all designed to maximize developer throughput.
But at Thoughtworks we've seen for years that, when teams genuinely embrace agile (the verb, small “a”, not the noun) approaches like XP, coding stops being the limiting factor. The bottleneck shifts to understanding the problem, making business decisions and validating that what you've built actually delivers the intended outcome and it can be deployed into production safely. AI hasn't created that shift, it has accelerated it.
Today, implementation is becoming increasingly abundant. The scarce resource is judgment. The new bottleneck is defining the right problem, making the right trade-offs and validating that the solution achieves the desired outcome.
When a constraint moves, the whole system has to rebalance. Roles change. Processes change. Measures of success change. The engineers who create the most value won't necessarily be those who write the most code, but those who can connect business strategy, customer needs and technology into coherent systems that AI can help implement.
Software was never really about writing code. It has always been about solving problems and creating sustainable value. AI has simply made that impossible to ignore.
This has direct implications for how we measure performance. If we're still optimizing for developer throughput, using metrics such as velocity, story points or lines of code, we're optimizing for yesterday's constraint. Increasingly, the measures that matter are the quality of the problem definition, the clarity of specifications, the speed at which decisions are made, the number of iterations needed before a solution is accepted and how much human intervention is required before software can be confidently released.
Document the ‘why,’ not the ‘how’
One of the sharpest reframings from the retreat was around knowledge management, or what I think we should start calling enterprise context engineering.
Agents can find or generate the "how." What they cannot recover is the "why": the intent, the trade-offs and the context behind a decision. Without that context, they can produce software that is technically correct but strategically wrong.
That's what documentation must now provide. Architecture decision records (ADRs) have always been good engineering practice. In an agentic world, they become load-bearing infrastructure because they preserve the reasoning that AI cannot infer.
This also explains one of the patterns we kept coming back to during the retreat: why experienced engineers consistently get better results from AI-first development than more junior engineers.
It's not because they're better at prompting. Their prompts are better because they bring years of accumulated knowledge, experience and judgment to every interaction. They instinctively understand the trade-offs, the architectural constraints, the historical decisions and the questions that need to be asked. That tacit knowledge shapes the context they give an AI, and ultimately the quality of the outcome.
The opportunity now is to make more of that knowledge explicit. Enterprise context engineering isn't just about helping agents. It's about capturing the judgment of experienced engineers so it can be shared consistently across teams, used by AI and passed on to the next generation of developers. If we want to scale AI effectively, we also need to scale engineering judgment.
The practical architecture questions remain unsolved:
What context should be centralized, and what should remain owned by individual teams?
How do we keep context current as systems evolve?
How do we create a trusted, "golden" view of enterprise knowledge that both people and agents can rely on?
Some organizations are already making real progress. Rather than relying on documentation that becomes outdated almost as soon as it's written, they're automatically constructing knowledge graphs from their codebases and architecture, creating a living model of their systems that humans and agents can query through standards such as MCP.
We've been experimenting with this approach at Thoughtworks for around three years. What surprised me was how novel it still felt to many people at the retreat. It reinforced just how early the industry still is in thinking about context as a strategic asset.
There's also a compelling economic argument for getting this right. Well-designed, modular software requires significantly fewer tokens for agents to understand and modify. That creates a direct line between engineering quality and operating cost. In a token-metered world, poor design isn't just technical debt. It's a recurring expense on your P&L. That's a very different conversation in the boardroom than simply arguing for better engineering discipline.
Success won't come from adopting another prescribed methodology. It will come from understanding the principles well enough to design practices that fit your team, your product and your constraints.
AI is taking us back to first principles
One of the more surprising discussions at the retreat wasn't about AI itself. It was about Agile (capitalization intentional).
For years we've debated frameworks, ceremonies and scaling models. AI makes that feel like the wrong conversation.
Traditional software development lifecycles were designed around expensive implementation. Agile improved on that by shortening feedback loops and helping teams learn faster. But as we tried to scale it, many organizations standardized the practices rather than teaching the principles. Stand-ups, sprints, story points and retrospectives became the goal instead of the mechanism. The thinking behind them was often lost.
AI changes the economics of software delivery once again.
When implementation takes hours instead of weeks, rigid sprint structures begin to matter less. Several teams described naturally moving toward more continuous, Lean- and Kanban-inspired ways of working, where the focus is on maintaining flow, reducing work in progress and shortening feedback cycles rather than planning work into fixed iterations. Others were experimenting with entirely different approaches.
One team described spending a day collaboratively designing a detailed specification, running an overnight agent pipeline and reviewing the results together the following morning. Another used AI during mobbing sessions to explore design options, challenge assumptions and capture architectural decisions as they happened. The practices were different. The principles were remarkably consistent: collaborate early, shorten feedback loops, validate quickly and continuously adapt.
Ironically, AI may push us back toward the original Agile Manifesto. Success won't come from adopting another prescribed methodology. It will come from understanding the principles well enough to design practices that fit your team, your product and your constraints.
That's a harder proposition than scaling ceremonies, but it's also where the real opportunity lies. AI is rewarding organizations that understand why Agile worked, not just how it was implemented.
Citizens build; experts set the boundaries
In February, supervisory engineering was one of the core ideas. In Switzerland, the organizational implications became much clearer.
AI is enabling people far beyond technology teams to build applications, automated workflows and AI agents with genuine capability. That is enormously exciting. It moves software creation much closer to the business problem.
But we're also seeing a predictable anti-pattern. Citizen builders create something useful, it gains traction and engineers are called in later to make it secure, scalable and supportable. That doesn't eliminate the bottleneck. It simply moves it to the organization's most experienced engineers, creating unnecessary rework along the way.
The better model is one where experts design the governance, citizens build within those guardrails and agents accelerate execution. Governance isn't something that's bolted on at the end. It has to be designed into the platforms, tools, policies and operating model from the outset.
A practical way to think about this is through risk rather than roles.
Personally owned tools can be built by individuals to improve their own productivity, but they should still use approved platforms, enterprise agent marketplaces and comply with the organization's security and data handling policies. Personal doesn't mean unmanaged.
Team-level automations operate in shared business processes or data. They require clear ownership, security review, compliance checks and appropriate governance before they're deployed because the impact of failure extends beyond the individual who created them.
Enterprise systems are different again. Where failure carries significant business, regulatory or customer impact, professional engineers should own the architecture, design, implementation and operation of the system. In many cases, citizen development won't be appropriate at all.
The key question is therefore not who built the software. It's what happens if it fails?
The higher the consequence of failure, the stronger the engineering discipline, governance and operational rigor that should surround it. AI democratizes software creation, but it doesn't democratize accountability.
Working alongside someone with ten more years of judgment allows you to borrow that experience before you've accumulated it yourself. In a world where AI removes many of the hard lessons previous generations learned through trial and error, deliberately transferring judgment may become one of the most important responsibilities of senior engineers.
The generation nobody's talking about
Much of the conversation around AI and talent focuses on two groups: new graduates and senior engineers. The group I worry about most sits in the middle.
New graduates often adopt AI naturally because they are essentially natives. Senior engineers, while sometimes more skeptical, have years of architectural instinct and engineering judgment to draw on. Its developers with five to ten years of experience who seem to be feeling the greatest disruption.
For many of them, the skills they've spent years developing, writing code, mastering languages and becoming better at implementation, are precisely the skills AI is rapidly commoditizing. The emotional friction is real, but I don't think that's the most important question. The bigger question is how we develop the next generation of senior engineers.
My belief is for decades, engineering judgment has come from two places. We learned from other people by pairing, collaborating and working alongside experienced engineers. And we learned the hard way.
Ask a room full of experienced engineers who has accidentally pushed something to production they shouldn't have, taken down a service or spent hours debugging a critical incident and every hand goes up. Those moments are painful, but they're also formative. They teach judgment in a way that no book or training course ever can.
AI is quietly removing many of those experiences. That's probably good for software delivery. Fewer production incidents are something we should celebrate. But it also means future engineers will have fewer opportunities to develop judgment through experience.
That was one of the most thought-provoking discussions of the retreat. Several teams described design quorums, specification reviews and collaborative design sessions where experienced engineers guide while others drive the interaction with AI. These aren't simply replacements for pair programming or code review. They're new mechanisms for transferring judgment before software is generated.
At the first retreat, we argued that code review could no longer be the primary mechanism for ensuring quality at scale. This feels like the next step in that thinking. Code review wasn't about finding bugs, it was also one of the ways we transferred engineering judgment. As that practice changes, we need to preserve the underlying purpose, even if the practice itself evolves.
I'm not convinced we've found the answer yet. It may involve pairing. It may involve design reviews, architecture quorums or entirely new ways of working that haven't emerged yet.
What I do believe is that pairing compresses experience. Working alongside someone with ten more years of judgment allows you to borrow that experience before you've accumulated it yourself. In a world where AI removes many of the hard lessons previous generations learned through trial and error, deliberately transferring judgment may become one of the most important responsibilities of senior engineers.
Security can no longer be a background concern
I'll finish with the theme that stayed with me most. Not because it was the most exciting discussion, but because I believe it's the most urgent.
Throughout the retreat, we talked about how AI is democratizing software creation. That opportunity comes with a corresponding shift in risk.
Software is no longer being created solely by professional engineering teams. Senior executives are building automations. Business teams are creating agents. Individuals are experimenting with tools that security teams often don't know exist. The attack surface isn't just growing because AI is becoming more capable. It's growing because many more people are now able to create software.
At the same time, attackers are adopting AI just as quickly. Vulnerabilities are exploited in minutes, sometimes seconds, after disclosure. Sophisticated attack tooling is no longer confined to nation states or highly specialized criminal groups. The barriers to entry have fallen on both sides. AI is accelerating defenders and attackers simultaneously.
This changes the conversation.
Security can no longer be something we review before production or teach through an annual compliance course. It has to become part of how we design platforms, govern AI and make day-to-day engineering decisions.
The technical practices are well understood: least privilege, strong identity for both people and agents, secure execution environments, defense in depth and limiting the blast radius when something inevitably goes wrong.
The organizational practices matter just as much. Approved AI platforms and marketplaces. Risk-based governance. Threat modeling before software is built, not after it's deployed. Clear ownership of AI systems regardless of who created them.
Ultimately, the question isn't whether organizations can afford to invest more in security. It's whether they can afford not to.
Every organization is investing heavily in AI to improve productivity and accelerate delivery. Those investments should be matched by a comparable investment in security, governance and resilience. Otherwise, we're simply accelerating our ability to create new vulnerabilities.
Five things to do now
1. Rethink what you're optimizing for.
If you're still measuring developer throughput, you're optimizing for yesterday's constraint. Shift your attention to problem clarity, specification quality, decision quality and the amount of human intervention required to reach production. You can't improve what you're not measuring.
2. Invest in enterprise context engineering.
Treat organizational context as strategic infrastructure. Capture the reasoning behind decisions, not just the decisions themselves. Build ADRs into your engineering practice, create living sources of architectural knowledge and deliberately preserve the judgment that your future engineers and AI agents will depend on.
3. Return to first principles.
Don't rush to replace Agile with another methodology. Instead, revisit the principles that made it successful: fast feedback, continuous learning, collaboration and responding to change. Design workflows around today's constraints, not yesterday's ceremonies.
4. Deliberately redesign how engineering judgment develops.
AI is changing how people become experienced engineers. Create opportunities for knowledge transfer through collaborative design, architecture discussions and specification reviews. We haven't yet discovered the perfect model, but we do know that deliberately transferring judgment will matter more than ever.
5. Govern AI according to risk, not roles.
The question isn't who built the software. It's what happens if it fails. Design governance into your platforms from the outset, establish clear risk tiers, invest appropriately in security and ensure engineering rigor increases with the consequence of failure.
The first Future of Software Engineering Retreat asked where rigor goes when AI writes the code. The second retreat asked a bigger question: what happens when coding is no longer the constraint that shapes software delivery?
The answer isn't another methodology or another AI tool. It's a redesign of how we think about software engineering itself. The organizations that succeed won't simply adopt AI faster. They'll rethink how they develop judgment, preserve context, govern risk and continuously adapt as the constraints continue to move.
If there's one thing both retreats have taught me, it's that the future of software engineering won't be defined by how quickly AI writes code; it will be defined by how deliberately we redesign the human systems around it.
Thanks for reading this edition of the newsletter. I hope these reflections help you navigate the next stage of AI-first software delivery. I'll be back in the autumn. If the last few months are anything to go by, we'll all have learned something new by then.
Warmly,
Rachel Laycock
Chief Technology Officer, Thoughtworks
CTO Reflections is a periodic newsletter from Rachel Laycock sharing observations on technology leadership, software development and the future of the industry.
Edition 1: Why AI is relocating engineering rigor