Why AI Code Slows Developers Down
Transcript
Made automatically from the audio, so it may contain mistakes. Click a line to play from there.
Picture this scenario, right? You are sitting at your desk. It's a Tuesday morning in late 2026.
Right. Just a regular Tuesday.
Yeah. And you just fed this wildly complex Jira ticket, like maybe a sweeping refactor of your core billing logic straight into your frontier coding agent.
Oh yeah. We all know that feeling.
Right. You just sit back and watch as it rifts through the entire code base. I mean, it analyzes all the dependencies, drafts the abstract syntax trees, and literally ten minutes later, a massive, fully fleshed out feature branch drops right into your lap.
It is an incredibly intoxicating feeling, honestly.
It really is. You feel like an absolute wizard. It's just pure flow state, right? Lightning speed.
Totally. Because the latency between human intent and functional syntax has well, it's practically vanished at this point.
Exactly.
You're no longer bogged down in all the boilerplate or you know, hunting down missing semicolons or trying to remember the exact parameter order for some obscure library function. The machine just pours out logic.
But then then the adrenaline wears off and reality just sort of hits a wall.
Oh, a massive wall.
Because that pull request you just opened, it sits in the review queue for four days.
Yep. Four days minimum.
Right. Your tech lead takes one look at the div, sees like three thousand lines of AI generated logic touching fourteen different microservices, and they just quietly close the tab. Nobody wants to touch it.
Nobody has the cognitive bandwidth to touch it.
Exactly. And when it finally gets rubber stamped, because let's be honest, they just skimmed it and hit approve.
Of course they did.
Right. So when it merges, the deployment pipeline completely chokes. Production rollbacks suddenly spike. I mean, you were writing code at a hundred miles an hour, but the team's actual velocity is completely flatlined.
Yeah, I mean we are living inside the defining paradox of modern software engineering right now.
It's wild.
It really is. I mean, the industry spent the last quarter century, basically the last 25 years optimizing the delivery pipeline. But they built it assuming the bottleneck would always be a human typing on a physical keyboard.
Right, human speed.
Exactly. And now we are generating code vastly faster than our systems, and honestly, more importantly, faster than our human cognitive limits can actually digest it.
I want to dig into the empirical reality of this. Because we actually have the data to prove this isn't just some collective fever dream or you know, just anecdotal complaining on forums.
We do.
Yeah. The METR 2025 randomized control trial looked at exactly this phenomenon. And the setup was rigorous. I mean, they didn't just ask some juniors to build a simple to do app.
No, not at all.
They took 16 highly experienced senior developers working on massive real-world open source repositories. We're talking projects with over 22,000 stars and millions of lines of historical code.
Right. And the methodology is really what makes the METR study so devastating to the whole current hype cycle.
Walk us through how they set it up.
So they split these senior engineers into two cohorts. They gave half of them frontier generative AI tools, specifically Cursor Pro running Claude 3.5 Sonnet. Okay. And they told the other half to work purely manually. So traditional IDEs, documentation, but absolutely no generative agents allowed. And both groups were tasked with solving deeply complex multi-file issues in these massive code bases.
No, intuition says the group with Claude 3.5 should just absolutely obliterate the control group, right?
That's what the marketing tells us.
Exactly. Because generative AI writes syntax at warp speed. And it could scaffold out an entire module in the time it takes a human developer to literally write the import statements. So how did the data actually land?
Well the empirical results are genuinely startling. They fly in the face of like every pitch deck released in the last two years.
Lay it on us.
The developers utilizing the Frontier AI tools actually took 19% longer to complete their assigned tasks compared to the control group.
Oh wait wait not 19% faster.
No.
19% slower.
19% slower.
Okay I have to stop you there because the mechanics of that slowdown are absolutely crucial. If the agent is generating the syntax instantly where on earth is that massive nineteen percent time deficit actually coming from that's a great question. I mean how do you lose that much time when the typing itself is automated.
The deficit comes from the shift in cognitive load.
Okay explain that.
When you write code manually you are building a mental model of the system architecture line by line, function by function. You understand the state management, the data flow, the weird edge cases because you personally wrestled with them.
Right. You're you're in the weeds.
Exactly. But when an agent generates three thousand lines of code for you, you are instantly thrust into the role of a forensic auditor.
Oh wow. Yeah. You are reviewing someone else's code but the quote unquote someone else doesn't actually understand the business context at all.
Precisely.
And the code is often aggressively plausible. That's the real trap of large language models.
Plausible, but maybe not correct.
Right.
Right. They don't write obviously broken syntax very often anymore. They write code that compiles, code that looks incredibly idiomatic, but it might subtly misuse a crucial internal API or you know, introduce a tiny race condition in how state is updated.
Or completely hallucinate the behavior of a third-party dependency.
Yes. Exactly. The developers in the Meta study lost massive amounts of time debugging incredibly subtle, highly plausible hallucinations that were just buried deep within these massive generated diffs.
That makes total sense.
Right. Because reading and verifying complex logic is fundamentally more time consuming and way more cognitively taxing than just writing it from scratch with intent.
And that leads to honestly the most dangerous part of the Meta findings, the psychological trap. Because despite being measurably 19% slower in reality, when they surveyed those exact same developers using the AI tools after the fact, what did they say?
The developers self-reported that they felt 20% faster.
They felt faster, but they were measurably slower. I mean, that gap between human perception and empirical reality is just an absolute chasm.
It's a massive blind spot for the industry. And if we broaden the lens a bit and look at the 2024 Dora data, the systemic picture gets even starker.
Yeah, let's talk about Dora.
So the Dora researchers found that AI adoption undeniably increases individual flow state and job satisfaction. Like developers are genuinely happier when they aren't writing boilerplate or looking up regex syntax on Stack Overflow.
Sure, nobody likes writing boilerplate.
Right. But that same AI adoption was shown to actively degrade software delivery stability and systemic throughput across the broader organization.
So we are essentially trading systemic organizational stability for individual typing speed.
That is exactly what we're doing.
We're optimizing for the local maximum of the single developer feeling productive. But it's at the direct expense of the global maximum of the team actually shipping reliable value to the user.
Which is really the entire catalyst for this discussion today.
Exactly. So welcome to part zero, the series overview of our deep dive into ways of working from agile to AI native.
Glad to be here.
If you are an engineering lead, a senior developer, a staff engineer, or a product manager trying to figure out why your team's velocity dashboards look absolutely incredible, but your actual product delivery is grinding to a halt. Well, this deep dive is designed specifically for you.
Yeah, and our mission throughout this whole series is to forensically map exactly how software teams actually organize their work.
Not the textbook versions, right?
The reality. We're going to trace the evolutionary lineage from the rigid, plan-driven days of waterfall through the agile rebellion into the industrialization of DevOps. And finally we'll arrive at the bleeding edge of modern AI-assisted agentic workflows.
And I want to set some ground rules right now. This deep dive operates on the assumption that you are a working practitioner in the trenches of software engineering.
We are definitely not holding your hand.
No handholding here. We aren't going to define what Git is or explain the basic mechanics of a pull request or define what an LLM or a unit test is. You know the tools.
You wouldn't be here if you didn't.
Exactly. We are going to cut straight through the sterile corporate textbook definitions and all that one true way dogma sold by those certification boards. We're looking at the empirical, messy reality of how software is actually constructed, integrated, and shipped.
Because to untangle this AI speed paradox, we can't just look at the LLMs themselves.
Right.
We have to look at the human delivery pipelines they are crashing into. We need to dissect the underlying mechanics of these historical methodologies, not just what the ceremonies are, but why they were forged in the first place.
Yeah, how they function under extreme pressure.
Exactly. And exactly why our current CICD and review systems are violently buckling under the sheer velocity of AI code generation right now.
Okay, let's unpack this. If the core constraint right now is this massive bottleneck where AI generated syntax slams into the human review process, we have to interrogate how our pipelines evolve to look like this in the first place.
Right, because it didn't just happen overnight.
No. The friction we are experiencing in 2026 isn't some random anomaly. It's the direct downstream consequence of how we have aggressively engineered our delivery systems over the last 25 years.
Absolutely. And to understand that bottleneck, we really have to wind the clock back to the predictive era, which really sets the foundation for what we're going to explore deeply in parts one and two of this series.
Let's do it.
If you look at Martin Fowler's seminal essay, The New Methodology, he brilliantly dissects the fundamental flaw of the traditional engineering mindset, the predictive, plan-driven approach that dominated early software development.
This is what we colloquially call waterfall today, but Fowler frames it around this concept of bridge-building envy.
Yes. That is the perfect term for it. Because for decades the software industry suffered from this massive inferiority complex compared to traditional civil and mechanical engineering.
Oh, definitely.
In civil engineering, the process is entirely predictive. You completely separate the design phase from the construction phase.
Right. The architect spends months drawing the blueprints.
Exactly. The structural engineers verify all the math, the load tolerances are calculated down to the millimeter. And only then do you hand those finalized locked-in plans to a construction crew. Right.
And the construction crew's job is not to be creative.
No, not at all.
Their job is to execute the blueprint with absolute fidelity. The person pouring the concrete doesn't suddenly decide halfway through the process to invent some novel experimental way to mix cement.
Right, because the parameters of the problem are fixed. The laws of physics are stable constants. Gravity doesn't undergo a paradigm shift on a Tuesday afternoon. Good point. The tensile strength of steel doesn't suddenly change because a competitor released a new product.
But Fowler argues that attempting to port this strict separation of design and construction into software engineering is a catastrophic category error.
It's a massive category error. Because software requirements are fundamentally intrinsically unpredictable.
Yeah, the business environment is highly volatile.
Exactly. You might spend six months designing a predictive architecture for a monolithic application, only to realize that by the time you reach the construction phase, the market has shifted entirely.
Users interact with the prototype and you realize all your initial assumptions were just completely wrong.
Or the third-party APIs you architected your entire data layer around just get deprecated without warning.
Right. So if you enforce a rigid predictive design phase in software, you basically guarantee that by the time you actually ship the code, you have built the wrong product perfectly.
That's a great way to put it.
Which is the exact pressure cooker that caused the agile reaction in 2001.
Exactly. A group of highly experienced practitioners met in Snowbird, Utah, and essentially declared that this bridge building metaphor was actively destroying the industry.
And they drafted the Agile Manifesto, which was less of a strict methodology and more of a, well, a philosophical inversion of priorities.
Right. They prioritized working software over comprehensive documentation. They prioritized welcoming changing requirements, even extremely late in the development cycle.
Because they recognize that the ability to adapt to new information is a massive competitive advantage, not a failure of planning.
Spot on. And most crucially for organizational physics, they prioritized business stakeholders and developers working together continuously on a daily basis.
Instead of the old way.
Right. They rejected the traditional model of negotiating a massive requirements contract up front, throwing a 200-page specification document over the wall to the engineering team and just sort of hoping for the best a year later.
But philosophy doesn't compile.
No, it doesn't.
When we talk about how that agile mindset actually materialized in the daily lives of engineering teams, we have to dissect the two major practical frameworks.
And it is incredibly vital that we separate the two.
Yeah, because they solve entirely different problems within the software lifecycle. So let's start with Scrum, because that is what ultimately conquered the corporate world.
Scrum is at its core a management wrapper. It is a system for organizing work, visualizing cues, and managing stakeholder expectations. But it explicitly does not dictate how to write code.
That's the key distinction.
Right. It's founded on the principles of empiricism. So transparency, inspection, and adaptation. You have highly structured artifacts, right? Like the product backlog to manage future work, the sprint backlog to manage current commitments, and the increment, which is the potentially shippable state of the software.
It provides a strict temporal cadence, the SPIT, to force the team to check their assumptions against reality, inspect the working software, and adapt their plan.
But here is the critical limitation of Scrum that everyone forgets. It has zero opinion on technical excellence. None. None at all. You could flawlessly execute every single Scrum ceremony. You could hold a perfectly timed daily stand-up, manage your story points with mathematical precision, hold deeply reflective retrospectives. Well, I should say deeply reflective meetings, and you could still be writing absolute unmaintainable garbage code that will collapse under its own weight in six months.
Let me push an analogy here, because I think this is where teams get fundamentally confused.
Okay, let's hear it.
Scrum is essentially the project manager organizing the front of house and the ticket flow in a high-end restaurant. Right. The Scrum Master ensures the ingredients arrive from the vendors on time. They work with a product owner to define the menu for the evening. They make sure the incoming orders are flowing smoothly to the different kitchen stations.
Right. They manage the flow.
And they hold a quick shift meeting to ensure the wait staff knows the specials and the VIP guests.
It is a purely logistical and communicative framework.
Right. But the project manager is not cooking the food. They aren't on the line searing the scallops.
Definitely not.
Extreme programming, XP, is the strict, rigorous culinary technique that the chefs are using on the line to actually cook the meal under immense pressure without burning the restaurant to the ground. XP is the internal engineering engine.
That's a perfect analogy. Yeah. And unlike Scrum, XP has incredibly dogmatic, strictly enforced rules that focus entirely on the actual syntax, the architecture, and the developer's immediate feedback loop.
XP doesn't care about story points.
No, it cares about code quality.
So break down the mechanics of XP, because I think a lot of modern developers practicing quote unquote agile have completely lost these core engineering practices.
Oh, absolutely. The cornerstone of XP is test-driven development or TDD. And this isn't just writing tests after the fact to satisfy some coverage metric on a dashboard. Right. TDD requires the developer to write the failing test before they write a single line of production code.
To stick with the kitchen metaphor, TDD is forcing the chef to taste the broth every single time they add a pinch of salt.
Exactly.
They are not allowed to blindly throw in five different spices, let it simmer for an hour, and just hope it tastes balanced at the end. The feedback loop is immediate and microincremental.
You write the test, you watch it fail, you write the minimum amount of logic required to make it pass, and then you refactor. It forces a decoupled, highly testable architecture by default.
And then you layer in pair programming on top of that.
Right. And this isn't just two people staring at a screen awkwardly. It is continuous real-time code review. One person is driving the keyboard, focusing on the immediate tactical syntax, while the navigator is thinking strategically about the broader architectural implications and edge cases.
It completely eliminates the sunk cost fallacy.
How so?
Well, if you're coding alone for six hours, you might go down a terrible architectural rabbit hole. And by the time you open a PR, you are too emotionally invested to throw it away. You just want to push it through.
Oh yeah, we've all been there.
But in pair programming, the navigator stops you five minutes down the rabbit hole.
Exactly. Combine that with continuous integration, so merging code multiple times a day to avoid massive integration conflicts, and the mandate for a sustainable pace to prevent cognitive burnout.
Right.
And you have an incredibly robust engineering engine. While Scrum was managing the business backlog, XP was actively preventing the code base from degrading into a toxic legacy hazard.
But there is a glaring scaling issue here.
Always is.
The Agile Manifesto and the strict disciplines of XP work beautifully for a team of eight highly communicative senior engineers sitting in a single room working on a single monolithic web app.
Sure.
But what happens when that startup becomes an enterprise? What happens when you have a thousand developers, or in the case of modern tech giants, 35,000 developers? You cannot scale a daily stand-up to 10,000 people.
No, you definitely can't. That scaling pressure is precisely what birthed the DevOps movement and the widespread adoption of trunk based development, which we will dissect heavily in parts three and four of our series.
Right.
As organizations scaled, they naturally defaulted to isolated teams working on massive, long-lived feature branches. A team would branch off main, spend two months building a complex new epic, and then attempt to merge it back.
Which inevitably result in catastrophic merge help.
Oh, absolute nightmare.
I mean, if my team spends eight weeks rewriting the database abstraction layer on our branch, and your team spends eight weeks rewriting the front end state management on your branch, the day we finally attempt to merge those branches together, the resulting conflicts will be so severe that the integration process alone might take three weeks of manual, highly error prone conflict resolution.
And the industry realized that delayed integration is a massive source of systemic risk. The solution to that was trunk based development.
Right.
You eliminate long-lived branches entirely. Every single developer, regardless of the size of the organization, collaborates directly on a single trunk or main branch. It is the literal manifestation of continuous integration.
But wait, the mechanics of that sound like a recipe for absolute chaos.
It does sound crazy at first.
If I have an organization to the size of Google, and they famously operate a massive monorepo with tens of thousands of developers all utilizing trunk-based development, how does the build not stay perpetually broken?
That's a fair question.
If 35,000 people are committing domains simultaneously, the sheer volume of untested, half-finished code should logically tear the system apart.
It would tear the system apart if they weren't utilizing extreme discipline around the specific mechanisms of integration. Trunk-based development at that scale relies heavily on decoupling deployment from release.
Okay, break that down.
They utilize extremely short-lived feature branches. We are talking branches that exist for a few hours, perhaps a day at maximum, never weeks.
And how do they merge half-finished features without exposing broken functionality to the end user?
Feature flags. They use feature toggles extensively at the code level. A developer can write the first 20% of a new feature, wrap it in a conditional feature flag that evaluates to false in production, and merge it directly into the trunk.
Wow. Okay.
The code is compiled, it is deployed to production, it lives alongside the active code base, but it remains entirely dormant and invisible to the user.
So you are continuously integrating the raw syntax, ensuring it doesn't conflict with anyone else's code, but the business release is completely decoupled. You release the feature weeks later with a simple configuration flip.
Precisely. And for deeper architectural changes, they utilize techniques like branch by abstraction.
Like when you need to swap out a vendor.
Exactly. If you need to completely swap out a legacy payment processor for a new vendor, you don't create a massive branch and rewrite the system in isolation. You create an abstraction layer in the trunk.
Right.
You route all traffic through the abstraction to the legacy processor. Then you incrementally build the new processor behind the scenes, continuously merging to trunk. You dark launch it, shadow the live traffic to both processors to compare the outputs.
Oh, that's smart.
Yeah. And once you have statistical confidence, you swap the abstraction layer to route to the new processor, and then you just delete the legacy code. The build never breaks, the trunk is always deployable.
But to execute deployment at that velocity, you cannot just rely on good git branching strategies. The application architecture itself has to fundamentally support rapid automated deployment, which brings us to the 12-factor app principles.
The 12-factor principles, which were originally drafted by the engineers at Heroku, serve as the architectural prerequisites for modern cloud native continuous delivery.
Right. You need these constraints.
If you want a pipeline that can deploy to production 50 times a day safely, you have to follow them. For instance, strict dev prod parity. Your local development environment must mathematically mirror your staging and production environments down to the exact versions of the underlying operating system packages and database engines.
Because if it doesn't, you run into the classic, it works on my machine catastrophe, which completely halts continuous delivery.
Exactly. You also have to treat all backing services, so your Postgres SQL databases, your Redis caches, your Kafka event cues, as attached resources that the application connects to purely via configuration injected from the environment.
The application code itself should have no hard-coded knowledge of where it is running. Right. I want to highlight my favorite factor, because I think it is the linchpin for scale. Executing the application as stateless processes.
Oh, absolutely vital.
Because if you want to scale out instantly, your application code cannot rely on local memory, local disk storage, or sticky sessions to maintain state between requests.
Right. If a user makes a request that hits container A and their subsequent requests hits container B, container B must be able to process that request perfectly by fetching the state from an attached backing service. Right. If a container crashes due to a hardware failure, the orchestrator should instantly spin up a replacement container, and the end user shouldn't even experience a dropped request.
So let's synthesize this. By combining trunk-based development, continuous integration, feature flagging, and 12-factor stateless architecture, we spent two decades building this incredibly tuned high-speed continuous delivery highway.
A beautiful highway.
Right. We optimized every single toll booth and on-ramp so that a human developer typing code manually could get their logic safely into production multiple times a day without breaking the system.
And that brings us violently crashing right back into our cold open and the AI speed paradox. We built a beautiful high-speed highway that was perfectly optimized for human traffic. The volume of code flowing through the pipeline was naturally limited by the physical speed of human thought and human typing.
But suddenly the bottleneck has physically moved.
The DevOps revolution succeeded. But now AI coding agents are acting like massive industrial dump trucks, dumping thousands of lines of raw syntax directly onto the on-ramp of our carefully curated highway.
Just piling up.
The CICD pipeline can deploy it, sure, but the human code review process, which is the necessary quality gate, is completely clogged.
If DevOps hyper-optimized the deployment phase, generative AI has now hyper-optimized the cogeneration phase. And that massive friction point is forcing the industry into a radical paradigm shift toward what is broadly being called agentic engineering, which we will explore into the deep weeds during parts five and six.
To cross the frontier into AI native development, we really have to grapple with the new economics of code. Simon Willison, who has been doing some of the most rigorous practical research on interacting with LLMs, drops this incredibly lucid truth bomb.
What's the truth bomb?
AI has made the act of writing code fundamentally cheap, but the cost of maintaining good code remains exceptionally high.
Let's push that further. It isn't just that the maintenance cost remains the same. I would argue the maintenance cost of AI generated code is often higher.
Yeah, that's a very fair point.
I mean, the cost of generating syntax is approaching zero. You press a button, get a thousand lines of Python. But over the next five years, human engineers still have to read that Python, secure it against zero-day vulnerabilities, update its dependencies, and adapt it to new business logic.
It doesn't maintain itself.
Exactly. If an LLM hallucinated a wildly complex, non-idiomatic abstraction layer because it got confused by a prompt, the cognitive cost to untangle that architecture is vastly higher than if a human had just written a simple procedural script.
That is the fundamental law of software economics in the agentic era. The reading is expensive. And to mitigate that, Willison maps out the specific mechanical patterns of how senior engineers are actually utilizing these tools.
Right.
We have moved far beyond just pasting a snippet of code from a chat window into an IDE. We are now engineering complex compound loops with autonomous agents.
Let's walk through the mechanics of that because the underlying technology enabling this has shifted rapidly. How do token caching and tool calling actually change the workflow?
Let's take token caching first, because it changes the financial and latency economics entirely. Okay. Previously, if you wanted an LLM to understand your massive React code base, you had to pass the entire context, say half a million tokens into the prompt every single time you asked a question.
Which is brutally slow.
Yeah, that takes 20 seconds to process and costs a fortune an API compute. Right. But with prompt caching, the LLM provider uses prefix trees in their attention mechanisms to basically hold your massive context window in active memory.
So you load the entire architecture of the monolithic application into the agent's brain once.
Exactly. And subsequent requests to that agent drop from 20 seconds of latency down to 200 milliseconds. And the cost drops by 90%.
That's wild.
The structural change is what makes agentic loops possible. You can now afford to have an agent constantly reading and rereading the code base in real time as you work.
And then you give the agent hands tool calling.
Right. Tool calling allows the LLM to execute functions outside of its neural network. It can run bash commands in your terminal, it can run grep to search your code base, it can execute your unit test suite and read the failure logs.
And it can even spawn subagents.
Yes.
Walk me through a scenario with a sub agent. How does that practically operate?
Imagine you were working with an agent like Claude Code, and you need to integrate a massive, poorly documented internal legacy API.
Sounds like a nightmare.
It usually is. Instead of the primary agent trying to guess how the API works, it spawns a specialized explore subagent. The primary agent tasks the subagent and says, go read the repository for the legacy API, execute a few test calls, map the exact JSON response structures, and return a synthesized summary of the required authentication headers.
So it delegates.
Right. The subagent operates in parallel, hits the network, gathers the ground truth, and reports back to the primary agent, which then writes the flawless integration code. It is highly autonomous, highly parallelized work.
It is brilliant, but it immediately circles us back to the Metter 19% slowdown data. Because Wilson pairs these powerful patterns with a massive, glaring anti-pattern warning.
The biggest warning.
You automated the generation phase, which made you feel 20% faster, but you forcibly shifted the massive cognitive load of understanding that logic onto your senior engineers during the review phase.
Yes.
That is precisely why the PR sits in the queue for four days. Reviewers open the diff, realize it looks like alien architecture, and they physically do not have the cognitive bandwidth to audit it.
And this realization that generating raw code faster is actively breaking our review pipelines is why the bleeding edge of the industry is urgently attempting to invent an entirely new workflow, which leads us to spec driven development or SDD.
If the problem is the code, maybe the code shouldn't be the primary artifact anymore. What is the core philosophy of SDD?
SDD posits that in the AI native era, the natural language specification, the spec, replaces the raw syntax as the primary source of truth and the primary artifact of software engineering.
So English is the new code.
Essentially, the developer's job is no longer to write the loops and the conditionals. Their job is to write incredibly rigorous, unambiguous English, and the agent acts as the compiler that translates that English into executable syntax.
Let's break down the mechanics of a robust SDD workflow using GitHub spec kit as a prime example. Because this is very different from just writing a long prompt in chat GBT.
Oh, vastly different.
You don't just open a blank file and ask the AI to build a feature. You begin by engineering a constitution.
The constitution is the foundational mechanism of spec kit. It is an immutable, strictly defined set of project rules written in Markdown.
What goes in it?
It outlines your architectural guardrails. It explicitly lists the testing frameworks to be used, the specific anti-patterns the AI must avoid, for example, do not use React context for global state, always route through Redux, and it establishes the security boundaries. It serves as the unyielding constraints for the agent.
And once the constitution is locked in, the developer moves the agent through a highly rigid, heavily checklist driven loop. Specify, plan, tasks, implement, and converge.
It is attempting to inject the extreme discipline of XP into the probabilistic nature of a large language model.
Okay, so how does the loop work?
The human writes the specification.
The agent analyzes the spec and generates a detailed technical plan.
The human must explicitly review and approve the plan.
The agent breaks the plan into discrete, manageable tasks.
The human reviews the tasks.
And crucially, before the agent writes a single line of logic during the implement phase, spec forces the model to run through an internal checklist.
Right. It slows it down.
Yeah. The agent has to literally pause, read the Constitution, confirm it is not violating the state management rules, confirm it is adhering to the testing standards, and only then is it allowed to generate the syntax.
It is a defensive mechanism against LLM hallucinations. But then you have platforms like TESIL, which take the SDD philosophy to its absolute radical extreme.
But TESL is attempting a one-to-one mapping where the natural language markdown file literally is the source file.
In a spec as source paradigm, the generated Python or JavaScript is treated merely as a compiled output binary. Right. It is tagged with a massive warning at the top that basically says generated from spec, do not edit. The human is forbidden from touching the syntax.
So if there is a subtle off by one error in how the pagination logic renders on the front end, I don't go into the JavaScript and change a greater than sign to an equal sign.
No, you can't.
I have to go into the markdown file, clarify the English description of the pagination logic, and command the agent to regenerate the entire file.
That is the aspiration, anyway. But it immediately triggers a very sharp, historically grounded critique from engineers like Brigida Boeckler at ThoughtWorks. She looks at SDD and asks a vital, terrifying question. Which is are we just repeating the most spectacular failures of software history? Because the industry has absolutely tried this exact paradigm before.
She is referencing model-driven development or MDD from the late 90s and 2000s.
Exactly. In the MDD era, the industry believed that writing code was too tedious and low-level, so they created complex UML diagrams and highly structured textual domain-specific languages.
Right, the DSLs.
The idea was that business analysts would draw the diagrams or write the high-level DSL, and a massive complex code generator would spit out the million lines of enterprise Java or C sharp.
But it failed miserably.
It failed because it sat at an awkward, leaky level of abstraction. The diagrams could never capture the necessary nuance of complex business logic, and the code generators were incredibly rigid.
Right.
When the generated code had a bug or a performance bottleneck, developers had to dive into the massive, unreadable generated Java anyway to fix it, completely defeating the purpose.
But Beckler points out that spec-driven development might actually be vastly worse than MDD.
Oh, it could be.
Because with MDD, the code generator was written in deterministic code. If the generator had a flaw, it was flawed consistently. You could track the bug down in the compiler logic. But STD is trading the rigid parsable languages of MDD for the extreme non-determinism and probabilistic hallucinations of large language models.
Which is a terrifying trade-off when you are dealing with mission critical systems.
Absolutely.
With an LLM, you can run the exact same markdown specification twice with the exact same temperature settings, and the agent might generate two completely different architectural implementations. One might use functional programming paradigms, and the other might default to heavy object-oriented classes.
So if the agent ignores the strict constraints in the Constitution because the context window got too noisy, what does this all mean?
Right, it's a mess. That is precisely the danger Buckler identifies. The massive million token context windows of modern LLMs give engineering teams a very dangerous false sense of control.
Oh, that makes sense.
We write a detailed five-page constitution and we assume the agent will flawlessly obey it because a human would. But LLMs operate on probabilities, not strict logical rules. Right. They will often completely ignore a crucial security constraint buried in page three of the Constitution, or conversely, they will go completely overboard, hyperfixating on an architectural guideline meant for the core monolith and wildly over engineer a simple 50 line utility script because they are trying too hard to satisfy the prompt.
It is the ultimate brutal irony of the AI era. We deployed generative AI to escape the drudgery of writing tedious syntax, only to find ourselves trapped in the vastly more exhausting drudgery of reviewing generated markdown, auditing probabilistic logic and debugging subtle AI hallucinations.
And if these sophisticated markdown constitutions are routinely ignored by massive language models operating in probability space, it forces us to interrogate the human systems wrapped around the AI.
Exactly.
If the model doesn't respect the system boundaries, how can we expect the human teams to? We are brushing right up against the fundamental physics of organizational structure.
Which moves us from the mechanics of how we build software to why these systems inevitably buckle and break when they collide with the reality of human organizations.
The messy human reality.
Yeah. Because whether you are practicing textbook agile, elite DevOps or bleeding edge spectrum development, you cannot escape the gravity of Conway's law.
Mel Conway published his thesis in 1968 and over half a century later it remains the single most undefeated immutable law in software engineering.
It really is.
Conway's law states that any organization that designs a system will inevitably produce a design whose structure is an exact copy of the organization's communication structure.
Their architecture is a mirror of the org chart.
Exactly. Let me give you a concrete scenario.
Please do.
Imagine an enterprise that decides to build a new e-commerce platform, but their organizational structure is heavily siloed. They have a front-end team in one building a back end middleware team in another and a database administration team that only communicates via heavily vetted Jira tickets. And they throw a hundred developers at the project.
Okay, because they are siloed the front end team doesn't want to wait for the back end team to build APIs, right?
Right.
So they build a massive bloated state management layer in the browser. The back end team doesn't want to negotiate with the DVAs for schema changes. So they build an incredibly complex, slow object relational mapper layer to manipulate raw JSON blobs in the database.
Precisely. They have produced a highly fragmented, deeply fragile, three-part architecture, not because it is the optimal technical design, but because it minimizes the painful cross-team communication required by their dysfunctional org chart.
Wow.
It absolutely does not matter if those teams are using waterfall, agile, or AI agents. The code inevitably reflects the communication graph of the humans.
Which is why the frameworks laid out in the book, Team Topologies, have become mandatory reading for modern engineering leaders.
Required reading, honestly.
If Conway's Law is going to dictate your architecture, you have to proactively design your team interactions to produce the architecture you actually want. Team Topologies defines three distinct highly intentional interaction modes to prevent your architecture from turning into an unmaintainable plate of spaghetti.
Right. You have collaboration mode, where two distinct teams work very closely together with high communication overhead for a strictly defined temporary period to discover a new technology or define a complex API boundary.
But you can't stay in collaboration mode forever, or the teams just merge into one massive, slow-moving monolith of communication.
Right, which is why you transition to X as a service mode. This is where one team consumes a robust, well-documented component provided by another team with absolute minimal friction and practically zero required communication.
Think of it like consuming an AWS service.
Exactly. The front-end team consumes the back-end API as a service. They don't need a two-hour meeting to understand it. They just read the docs and use it.
The third mode is facilitation, where a specialized team, perhaps a platform engineering or a site reliability team, actively mentors and clears roadblocks for a product team without taking ownership of the product team's code.
The overarching critical takeaway from team topologies is that leadership must focus relentlessly on the flow of value rather than a static hierarchical org chart. And to maintain that flow, you must ruthlessly, obsessively manage team cognitive load.
Define cognitive load in this context, because I think it ties directly back to our AI bottleneck.
Cognitive load is the total amount of mental effort being used in the working memory of the team. Okay. If a product team is overwhelmed just trying to understand the Byzantine complexities of their deployment pipeline or trying to decipher an undocumented legacy API, their cognitive capacity is maxed out. They physically have no mental bandwidth left to deeply understand the user's business problem.
And if you blindly deploy AI coding agents into that environment, you are drastically increasing the cognitive load.
You're just adding fuel to the fire.
You are flooding an already overwhelmed team with massive pull requests, full of code they didn't write, don't fully understand, and now have to audit.
You are burying them. And the danger is that organizations often think they are solving these problems by adopting new methodologies, but they fall victim to semantic diffusion.
This is another concept from Martin Fowler. Semantic diffusion is what happens when a highly specific, rigorous methodology spreads throughout the broader industry, and in the process of being commoditized and sold by consultants, it completely loses its original strict meaning.
The most glaring example is what the industry calls zombie scrum.
Oh, zombie scrum.
Yeah, a large enterprise realizes they are moving too slowly, so they mandate an agile transformation. The teams go through the hollow superficial rituals, they stand in a circle for 15 minutes every morning. They estimate their work in Fibonacci sequence story points. They use Jira, and they call their two-week work cycles sprints.
But beneath the surface, nothing has actually changed.
Nothing at all.
They have no automated test coverage, no continuous integration. They still require manual QA approval from a separate department, and they only ship code to production twice a year.
They are performing the rituals of Agile while entirely lacking the engineering principles that make agile function. The word has been semantically diffused into meaninglessness.
And we are already seeing this exact same corruption happening with spec driven development in real time.
Oh, absolutely.
I see teams claiming they are doing SDD, but when you look at their workflow, they aren't writing immutable constitutions or utilizing rigid task planning loops. They are just using the word spec as a fancy marketable synonym for really long rambling prompt pasted into ChatGPT.
Exactly. The methodology is corrupted the moment it hits the reality of corporate metrics, which ties us directly into the Goodhart's Law trap. Charles Goodhart was an economist, and his law states that when a measure becomes a target, it ceases to be a good measure.
Let's apply that directly to software engineering, specifically the famous Dora metrics. For the last decade, the DevOps research and assessment group has provided the industry with the absolute gold standard for measuring delivery performance.
The gold standard. When observed organically, those metrics are incredible, highly accurate indicators of systemic organizational health. If a team's deployment frequency is high, say multiple times a day, and their change fail rate is low, it strongly indicates that the team has excellent automated testing. They are working in small, manageable batch sizes, and there is a high degree of trust and psychological safety within the engineering culture.
But the moment a well-meaning VP of engineering looks at those metrics and declares our OKR for Q3 is to increase deployment frequency by 20% across all teams, they have triggered good hard slaw.
Because developers are rational actors, optimizing for the system they are in. If you tie their bonuses or performance reviews to deployment frequency, they will game the metric.
I have literally seen this happen. A team will write an automated script that changes a single comma in a benign markdown file, commits it and deploys it to production a hundred times a day.
Yep, I've seen that too.
The deployment frequency metric goes through the roof. The dashboard is bright green. VP is thrilled. But absolutely zero business value has been delivered to the end user. The metric became the target and therefore became completely useless as a measure of health.
And that dynamic is the most vital, sobering insight to emerge from the massive 2024 DORA report.
What did they find?
The researchers analyzed data from tens of thousands of professionals worldwide, looking at the impact of AI adoption, platform engineering, and metric-driven management. And they found that the ultimate driver of high performance isn't raw code volume. It isn't how fast your agents can type. It certainly isn't perfectly executed zombie scrum rituals.
Then what is it?
The single biggest driver of software quality, systemic performance, and team well-being is user centricity.
Great. Unpack that.
User centricity outperforms technical tooling.
By a massive margin?
Organizations that build their entire process around deeply understanding and prioritizing the end user experience build objectively better products. And crucially, developers in highly user-centric environments are significantly less likely to experience burnout because their work has clear, validated meaning.
But the flip side of that 2024 Dora data contains a stark, almost brutal warning about organizational stability, right?
It does. The Dora researchers found that unstable organizational priorities cause massive systemic burnout. And here is the terrifying part.
Meaning you can't buy your way out of it.
Exactly. It absolutely does not matter if you have elite, perfectly tuned CI CD pipelines, if you give every developer access to frontier AI models, or if you have world-class internal platform documentation. If executive leadership constantly radically changes the strategic priorities of the business, developer productivity drops off a cliff and burnout skyrockets.
We have to pause here because the irony of this is staggering.
It's a full circle.
How do we reconcile that?
You reconcile it by recognizing the vast difference between a changing requirement based on user feedback and an unstable priority based on organizational chaos.
Okay.
Agile was designed to let a product team pivot the specific functionality of a feature because they put a prototype in front of a user and the user said, Actually, I need this data visualized differently. That is a healthy, user-centric requirement change. Right. Agile was not meant to allow the CEO to read a magazine article on an airplane and change the entire strategic direction of the company every two weeks.
AI generating code rapidly does absolutely nothing to help if the team doesn't have stable user-centric priorities. You just generate the wrong code for the wrong strategy vastly faster.
Exactly. You are just accelerating into a brick wall.
So we have covered a massive amount of conceptual ground today. We have traversed from the very real AI speed paradox through the evolutionary history of Agile and DevOps, explored the bleeding edge of spec-driven development, and grounded it all in the inescapable physics of Conway's Law and the Dora metrics.
It's a big landscape.
It is. To wrap this up, if I am a listener heading into the office tomorrow morning, how do we distill this vast theoretical landscape into practical, actionable takeaways?
If you are leading a team or if you are a senior engineer just trying to survive the current chaos, you need to diagnose your specific, localized systemic constraints before you adopt any new tool or methodology. I propose three diagnostic questions you can ask your team at tomorrow standup to locate your true feedback loop bottleneck.
Let's hear them.
Question one where is our actual friction? You need to physically map your value stream from idea to production. Are you currently bottlenecked at the code generation phase? Does it take your team days to write boilerplate crud endpoints? If so, injecting generative AI tools like cursor or GitHub Copilot will give you a massive immediate velocity boost.
But wait.
But if your friction is at the code review phase, validation and PR merges, which is the empirical reality for most mature enterprise teams, then blindly injecting AI into the generation phase is actually going to actively hurt your team, exactly as the METR RCT study demonstrated.
Right, because you're optimizing the wrong step.
You will simply pile up unreviewed complex code faster, increasing cognitive load and slowing down systemic throughput. You have to identify the actual constraint before you attempt to optimize.
That is critical. What is question two?
Question two. Are we measuring the right thing? Or are we gaming the system? Look critically at your team's dashboards and OKRs. Is your process prioritizing raw code volume, velocity story points, and strict adherence to scrum rituals? Or are you measuring validated user-centric outcomes?
The good hard slaughter.
Exactly. If you are managing to Dora metrics as targets to be hit rather than indicators of systemic health, you have fallen into the trap and your metrics are lying to you.
And the final question?
Question three. Are we fighting our architecture? Look at your organizational chart, look at how your teams communicate, and then look at your code base. Do your team boundaries and permission structures directly conflict with the reality of Conway's Law?
Give me a practical example of fighting the architecture.
If you are trying to implement elite DevOps practices like trunk based development with 50 developers, but your organizational rules require a cross departmental manual architectural review board to approve every single pull request before it merges, your human structure is actively fighting your desired technical architecture.
Oh, yeah, that's never gonna work.
You will never achieve continuous delivery. You have to align your communication paths with your technical boundaries, utilizing the interaction modes from team topologies.
Those three questions alone. Locating the true friction point, auditing your metrics against Goodhart's law, and aligning your org chart with Conway's law can save an engineering team months, if not years of wasted effort and burnout. And this overview was just setting the stage.
This was merely mapping the territory we are about to explore.
Next time, in part one of our deep dive, we are going to put the history of Agile under a forensic microscope. The next part is titled Why Agile Happened.
It's gonna be a good one.
We will take a detailed look at what the predictive waterfall methodology actually got wrong in the defense and aerospace industries of the 80s and 90s, and then we will explore the tragedy of how the radical Agile Rebellion was ultimately hijacked, packaged, and sold by certification boards and sterile corporate playbooks.
It is a deeply fascinating history that explains exactly why so many talented developers today feel profoundly alienated and frustrated by the processes they are forced to use. But before we sign off, I want to leave you with a final provocative thought to mull over regarding the future of our profession.
Lay it on us.
We are rapidly entering an era where AI is effectively driving the economic cost of writing raw syntax down to zero. If that trend holds true, the future of the mythical, highly sought-after 10x developer is going to look completely alien to what it looks like today.
It won't be the person who memorized the most API endpoints.
Exactly. It won't be about who can hold the most complex, arcane architecture in their working memory, or who can write 3,000 lines of flawless rust in a weekend caffeine binge.
Right.
As the generation of syntax becomes free and instantaneous, the most valuable, highly compensated skill in software engineering will shift entirely. It will become the ability to aggressively simplify systems. It will be the courage and the architectural insight to confidently delete code.
Because less code means less surface area for AI hallucinations and lower maintenance cognitive load.
Precisely. And most importantly, the superpower of the next decade will be acting as an expert translator. The role of the engineer will be taking the messy, contradictory, deeply ambiguous nature of human business needs and translating them into rigorous, airtight, mathematically precise specifications that a probabilistic agent can safely and deterministically execute. The future of coding is no longer about typing syntax faster. The future of coding is clarity.
The future of coding is clarity. I love that. Thank you for joining us on this deep dive. Take those three diagnostic questions to your team tomorrow. Evaluate your actual bottlenecks, and we will see you in part one.