~/posts/the_productivity_trap.md─□✕

The productivity trap

John Mikael Lindbakk // 16/11/2026 14:00

In the wake of AI there has been a lot of focus on productivity. There have been claims of 100x and even "easily 1,000x" engineers, and an industry-wide panic about falling behind. Companies mandate AI usage, leaders want to know how much faster their teams have become, and developers worry about being left behind by those who have gone all in.

I feel the focus on productivity is both misguided and short-sighted. Not because productivity doesn't matter, but because it has become the only aspect we talk about.

In this post I'll go through some of the aspects that get lost when productivity is all that matters: what productivity even means, how well we understand our own systems, how quickly we can answer questions about them, the people our software affects, the new ways things can go wrong, who is responsible when they do, the long-term health of our codebases, and where all that extra productivity actually goes.

Note

Sigh... I feel like every time I speak about AI I have to include this disclaimer...

The conversation around AI is so touchy that nuanced takes are read as extremes, and the willingness to misunderstand is very high.

I'm not saying that we shouldn't use AI, or that anyone is bad for using it. I use it myself. What I am against is chasing productivity at the expense of everything else. There are tradeoffs, and we barely talk about them.

What is productivity anyway?

We say that productivity has increased, but nobody really talks about what productivity even is. When it comes to software development it seems like the only things that matter are the number of pull requests merged or the number of features shipped, but that is fundamentally wrong.

We've long known that lines of code is a largely useless metric. The number of fixed bugs isn't much better, because it doesn't say much about why the bugs existed in the first place. Change Failure Rate (CFR) is a much better metric, but it doesn't measure productivity, only how often that productivity turns into failures in production.

The truth is that we cannot measure productivity, and every attempt I've seen has been fundamentally flawed.

Whenever I see someone claim productivity gains, I get worried about what they actually mean. Is it just a vibe? Is it lines of code? Is it Mean Time to Resolution? Is it based on time spent on a specific task? Some of these metrics are valuable, but none of them are adequate for measuring productivity.

For some, I suspect it is the "number of features" implemented within a period of time, but this is also a flawed metric. Not all features are useful or desired. Not all of them lead to favourable outcomes. Good systems are not defined by the number of features. Heck, in my experience more features can work against a product (often called "bloat").

Part of the problem is that we mix up output and outcome. Output is what we produce: code, PRs, closed tickets, shipped features. Outcome is what that output actually does for the business and its users. A team can double its output and leave the outcome unchanged, or even make it worse, by shipping features nobody uses that someone now has to maintain. The most productive thing a developer does in a week might be deleting a feature, or talking a stakeholder out of building something in the first place, and no metric I know of would give them credit for that.

Even the people who research developer productivity for a living warn against boiling it down to a single number. The SPACE framework argues that productivity spans satisfaction, performance, activity, communication and efficiency, and that you need several of these at once to get anything resembling a full picture. And the moment one metric becomes the target, Goodhart's law kicks in: tell people that PR count matters and you'll get more PRs. Whether you get more value is another question entirely.

So when someone says they're "10x more productive", I can't help but wonder: "10x of what, exactly?"

Even the research can't settle it. One study found developers 55.8% faster with Copilot, another found no speedup and more bugs, and a third found experienced developers 19% slower with AI. They don't really contradict each other, because each one measures something different: how fast freelancers wrote a small HTTP server, how many bugs got logged before and after getting Copilot, how long experts took on code they already knew inside out. Each result says something about that specific scenario, and very little about "productivity" in general. Pull the number out of its context and it says about as much as lines of code does.

It is worrying that so many people make productivity claims without saying what they actually measured, and it is worrying how much weight we put on those claims.

Self-built black box

Throughout my career I've heard developers talk about black boxes: closed-source systems in their solutions that they don't really have control over, or third-party code and dependencies they don't really understand. This talk has always been negative. In short: we don't like black boxes... yet now we embrace them.

There are accounts of people developing 100% with AI and no longer understanding their code. I've also seen this in colleagues, where the solution is generated, but they don't actually know what happens under the hood. A lot of companies claim this is a good thing, like Bislab in Norway, which has made it a general rule that its developers no longer write code by hand.

The "100% AI-generated code" trend is problematic, because not writing code leads to less understanding of said code. After all, coding is something you do, not something you read - much like carpentry. I can read a book on how to build a chair, but books can only take me so far when it comes to actually building that chair. Doing the actual work gives you insights that would otherwise be lost. It raises questions that are valuable to answer. AI proponents would say that every problem is a prompting problem, but I disagree: there is value in the understanding you get from writing the logic that props up the business.

I feel the logic is self-evident: The more thinking allocated to LLMs, the less thinking you're doing. The more decisions the LLM makes, the fewer you're making (or maybe even fewer decisions you're aware of). As such, the intimate knowledge of the inner workings of a codebase will deteriorate the more AI is involved in the process.

The usual counter-argument is that this is just another layer of abstraction. Few understands the assembly their compiler spits out either, so why should code be any different? But a compiler is deterministic and battle-tested: the same input gives you the same output, and when it does something unexpected, that's a bug in the compiler that gets fixed. An LLM can give you a different answer every time you ask, and plausible-looking output is exactly what it is good at. You can trust the compiler without reading what it produces. You can't say the same about generated code.

And sure, no developer understands every line of a large codebase. There's legacy code, code written by people who left years ago, and code you wrote yourself and have long since forgotten. That has always been a problem. But it is a problem we've always tried to reduce, through ownership, documentation and people who have been around long enough to know where the rough edges are. Generating everything does the opposite: it turns all of the code into code nobody has written.

If I were a CEO, I would be highly worried if I now had developers who don't understand the inner workings of the systems the business relies on to be... well... in business. Maybe the long-term idea is to phase out developers, but that doesn't really solve the issue. If anything, that would be an even worse idea in my opinion.

Does a business actually want to depend on a system nobody understands, where if it blows up they have to rely on LLMs to get it working again... praying that the LLM hasn't painted them into a corner they can't get out of? To me that sounds like a potential existential threat, especially if the developers have lost their tech chops from relying on AI all the time.

What happens if Mr. Claude has a bad day and goes offline... while your system also blows up... AND your developers have no idea what they're doing? What do you do? Just wait until things come back online? Can your business handle that? Can your business handle the long-term loss of trust?

I find it baffling that this is an approach leaders embrace and push for.

Mean Time to Answer

In software we have "Mean Time to Resolution" as a metric. It is a pretty good metric that says something about a business's ability to fix a problem and how long it takes to do so. The black box pushes forward a different, internal metric: Mean Time to Answer.

As a developer I engage with a lot of non-developers. That can be various stakeholders, leaders, even customers at times. A bunch of people who rely on the system, but don't have the knowledge to find the answers they seek (because that is not their job: they are not developers). A big part of the job is being available to non-technical people and helping them, and a core part of that is answering questions.

Assume that a solution is fully AI-developed, and you walk over to a colleague and ask about an edge case. Guess what... they won't be able to give you a straight answer unless they ask an LLM, simply because they're no longer that involved in the development.

Writing things down has consistently been the best way to remember something, and that is what we're doing when writing code. We remember the inner workings of the system because we engage with it by writing it, which lets us provide an answer on the spot. This is incredibly valuable in meetings, in general day-to-day work and when planning. Without it, we end up with constant breaks to prompt our way to answers for every question that comes up.

There is also the human part of it: if you ask someone and they have to prompt for the answer... do you trust it? It is clear that they had no clue either, so does it really reassure you that someone else did the prompting?

The response to this argument is often the one AI proponents tend to give: just add more AI. Why even bother asking a person? Why not ask the LLM directly?

I find that response atrocious. Conversations between non-technical and technical people are a good thing. That bridge-building leads to better products overall. But by pushing everyone to get their answers from LLMs, we now have non-technical people taking output from an LLM which they cannot verify, because they are non-technical. Even a developer who no longer knows the code inside out still has the technical chops to look at the answer and go "Wait, this doesn't look right" and then challenge the AI for a correct answer. Non-technical people don't have that luxury.

By creating this black box we've either increased the Mean Time to Answer or increased the risk of giving faulty answers. Both are bad tradeoffs.

Oh wait, it gets worse!

Alright, so management has heard all of that, shrugged, and signed off on the black box anyway. After all, who cares? Productivity! Potential profit! (Well, it is still up in the air whether this is actually the case, but hey, "potentially" is good enough, goddammit!) Let's roll the dice and start vibin'! Don't let ol' unc John drag you down with his negativity!

Look at you go there, young whippersnapper - productivity soaring, code being generated like never before and tokens being burned 24/7. What a sight to behold!

Sure, nobody understands the system and nobody knows whether it is mostly held together by prayers and duct tape, but it works well enough to make money, and isn't that all that matters?

Buuuuuuuut... software does not live independently from the real world. For better or worse, our systems impact lives in ways that are hard to predict.

We have the obvious scenarios, like healthcare software where an error in a dosage calculation can be disastrous. Or what about our beloved flight software? The big known cases here are pre-AI (Therac-25 and the Boeing 737 MAX's MCAS come to mind), so we cannot blame AI for them, but would you feel more or less at ease if these kinds of systems were now developed with AI? What about the lane assist in your car? What about the self-driving trucks that companies are trying to roll out? Would you sleep better if more and more of the code in those critical systems were LLM-generated?

What happens to the safety of actual human lives, when the goal is to increase productivity by decreasing human involvement? Would you dare tell your customers that the code was primarily written by AI? What do you think the government will think if they come knocking for an audit?

Unfortunately, this concern is not limited to the obvious, "life-or-death" critical systems.

Take this case from 2020, where Alex Kearns, a 20-year-old, took his own life thinking that he owed hundreds of thousands of dollars. His trading app showed a negative balance of around $730,000, and the platform had sent an automatic email "requesting a payment of more than $170,000 in just a few days".

He is not the only one. In the UK, bugs in the Post Office's Horizon accounting system made it look like money was missing from branches. Around 1,000 subpostmasters were prosecuted between 1999 and 2015, and the public inquiry found that at least 13 people may have taken their own lives because of it.

Or what about Australia's Robodebt scheme, which used automated "income averaging" to raise around 470,000 debts that people didn't actually owe? The Royal Commission linked it to suicides, not to mention the psychological toll on everyone else who received a debt notice.

The examples are countless, but the problem doesn't have to be as large as loss of life. Michigan's unemployment fraud detection system, MiDAS, accused around 40,000 people of fraud between 2013 and 2015, and a state review found that 93% of the fraud determinations made by the computer alone were wrong. Or Rite Aid, which used facial recognition software that falsely flagged customers as shoplifters, leading to people being followed around the store, searched, and even having the police called on them. The FTC ended up banning Rite Aid from using facial recognition for five years.

It is not hard to imagine even more indirect bugs causing issues, like a reporting tool that should pick up certain issues not working correctly, letting certain usage of the system fly under the radar long enough that it ends up doing serious harm. Or security flaws exposing people to identity theft.

Heck, let's consider B2B companies where we sell software to office workers: we still impact their daily lives at work. We can delight them and make their day easier, or we can make it stressful and frustrating.

The point is that our software impacts people's lives. The consequences can be extreme, like loss of actual lives, or as small as irritation... and the entire spectrum in between. Software scales everything, both functionality and anguish. Its wide reach can turn a small bug, like a confusing bank balance, into something disastrous.

I feel that a lot of developers forget their duty to their users. And so do companies. They focus on productivity because profit is what matters, but some core underlying tenets get forgotten.

Given that we impact people's lives: is 100% AI-generated code, creating a black box, actually the right approach? Would your users be comforted by that fact? What if it came out, right after a serious bug, that you no longer write your own code? Would that news headline be good PR for the company?

My view is that we were already failing our users before the AI wave. Too many developers cared too little, and management was no better. Enshittification was well on its way in most software, and corners was (and still are) cut all over the place, and it has not gotten any better.

If AI is an accelerator, I fear it is an accelerator of things that we might not want to be accelerated.

"But John, humans make mistakes as well! It ain't AI's fault!"

Good point, hypothetical reader! Most of my examples here are from before AI usage became widespread, so they cannot be AI's fault. Busted!

...but hear me out.

I would like to introduce the concept of "vectors of errors". It is similar to attack vectors, where the idea is that the more pieces you have in a system, the more places you can be attacked from. These don't have to be technical; they can also be social, like phishing attacks to get access to computers with admin rights.

When we talk about vectors of errors, we have to consider what can introduce errors. This includes (but is not limited to):

  • Poor management decisions (unreasonable deadlines, enforced practices that don't actually help, incentives that actively harm the company, etc.)

  • Team culture (attitudes towards end users, how they work, internal standards, etc.)

  • Developers (experience, personal attitudes, professionalism, etc.)

  • Technical (testing methodology, code quality, robustness of deployment and infrastructure, etc.)

AI becomes another vector of errors. Now we have another contributor to the solution, which may introduce mistakes or contribute to them.

Sure, we might say that it is still the developer's responsibility, and that is true. But in practice, the more AI-generated code we embrace, the more developers mentally offload that responsibility onto the machine, even though it never actually moves. Especially when parts of the industry now see PR reviews as a bottleneck that needs to be solved (often by just adding more AI to the process).

Without getting into the discussion about whether AI-produced code is good (I think it is a mixed bag), we must at least admit that it is a new area for errors to manifest.

Sure, if the AI writes a line instead of a human, the human can't make a typo or forget a null check in that line, so you could argue that some errors simply move rather than multiply. But the kind of error matters more than the count. AI-generated code looks plausible by design, so its mistakes are exactly the kind that slip through a quick review. And the thing best suited to catching them, developers who deeply understand the code, is the very thing we're trading away. We can reduce the impact of that vector, but we cannot eliminate it. The base cost is there regardless of what we do.

What I find fascinating is that when talking about productivity, we cannot get away from balancing being involved in and familiar with the code against getting code produced fast. It is a balancing act. You cannot have it both ways.

Think of it as a spectrum:

No AI → Fully AI-written code with human reviews → Fully AI-written code with AI reviews

The further right you go, the more code you get, and the less human involvement you've had. And basic logic also says the less understanding of the code you have as well.

The best way to understand and be familiar with the code is to write and work with it. Reading it can only take you so far. Even reading takes a long time, so if the goal is to maximise productivity, you also have to reduce your involvement in and understanding of the code. Every step towards more speed is a step away from understanding.

Reducing understanding widens AI as a vector of errors, while the developer's existing vectors of errors are all still there: developers can still misunderstand, their experience still plays a role in what they can detect, their personal attitudes still affect the final result and what they're willing to risk, etc. So we're widening one vector of errors without really narrowing the other.

People might argue that this is a worthwhile tradeoff. And yeah, that is largely subjective and often determined by what people are comfortable with and their values, but let's at least acknowledge that there is a tradeoff. I would also argue that whether it is worth it must be seen in the context of what is being built and the impact it may have on actual humans.

If this is software that can do real harm when something goes wrong, then I would question whether we should, or want to, open up extra vectors of errors.

So no, I'm not saying that AI will automatically cause the next Horizon scandal. I'm saying that those examples are the stakes. Software already hurts people when it goes wrong, and we're now adding a new source of errors while getting rid of the deep understanding that is supposed to catch them. Whether that is an acceptable trade is a conversation every business should be having, and right now most aren't, because productivity is the only thing on the table.

The responsibility question

When talking about vectors of errors I also brought up the spectrum from no AI to fully AI-written (and AI-reviewed) code, and that there are tradeoffs along it. One of them is responsibility.

The more we automate, the more responsibility we feel we can offload to something else. Sometimes that is a worthwhile thing to do. For example, having a security tool scan my dependencies is much better than me going through them one by one and staying on top of every CVE. So leaning on a tool is not necessarily a bad thing, but I think we should ask ourselves where to draw the line. I suspect different people will come to different conclusions.

What I think we must be aware of, and have more conversations about, is how AI impacts this. Especially in organisations that are trending towards automating as much as possible with AI: where do you hand the decisions to the machine, and do you still feel responsible for them afterwards?

There are plenty of people out there who claim that AI does the testing, implementation and deployment, while they essentially sit in an issue tracker (like Linear) and manage it. We cannot deny that a lot of decisions have been handed to the LLM in such a setup, and with them, at least mentally, a lot of the responsibility. And if this is what we want the industry to be, then we must also accept that we're giving LLMs the power to make decisions.

Once we accept that we're giving LLMs the power of decision-making, we must also ask ourselves: in what way can an LLM be responsible?

Human developers can be held responsible. If they don't live up to that responsibility, they can get fired. And we can build trust over years as they work within an organisation. An AI doesn't actually care if it gets replaced, and the "building of trust" goes as far as its context window allows. An LLM does not care whether it created a bug that took a life.

Let's be clear about the "nature" of LLMs: they are not thinking creatures. They are not living, and they are not thinking. They are statistical models, trained on enormous amounts of text to predict the next token. We can be as impressed by the output as we like, but at the end of the day it is just 1s and 0s. There's nobody in there: nothing that can feel, care, or answer for what it did. Just an application.

Given that it is "just an application", we also have to reckon with the fact that we are assigning a lot of responsibility to that application, and giving it a lot of power to make judgement calls. An IBM training slide from 1979 is often quoted on exactly this: a computer can never be held accountable, so a computer must never make a management decision. If it fucks up, it cannot be held responsible... yet we now see companies boasting about not doing "manual coding".

Which leaves us with an uncomfortable truth: the responsibility never actually moved. It is still yours, whether you wrote the code, skimmed it or never looked at it at all. The more we offload to the machine, the more we have to reckon with being responsible for decisions we didn't make and code we don't understand.

This is one of the big issues I have with how people use LLMs these days. It seems that the "responsibility question" is downplayed or pushed to the side, because "we gotta go fast".

Long-term productivity gain is still unproven

It is not a new phenomenon that both businesses and developers struggle with long-term thinking. The business focuses on the next quarter, and developers often focus on the current project... or sprint. Development has, unfortunately, been structured around short-term thinking.

When I ask developers what their job actually is, I often get the response "solving problems", and I disagree. Our job is to build something valuable to the business or its customers, something that helps the business being profitable (or turning it profitable). Solving problems is part of that, but it is not the entirety of our job. And yeah, this is boring and business-y, and I don't like it either, but seeing ourselves as people with an actual responsibility to the organisation that employs us, rather than as "problem solvers", changes how we think about our code long-term.

Consider this: why do we care about technical debt? Sure, some care about it for the love of the game, as an academic pursuit (and heck, I can fall into that camp easily). Some care because they want less fuss in the future. Some care because... well... it's the right thing to do, innit? And some don't actually care at all, but those people are lost and we shall ignore them.

Whatever answer you come up with is fine and valid to you, but the underlying reason is always that a codebase that can be easily altered, with a reduced chance of bugs, sets the business up for long-term success. Consider this: does technical debt matter if nobody uses the application and nobody relies on it? No, it doesn't. Nobody cares, so the quality is completely irrelevant.

So how does this relate to AI? (Another good question there, hypothetical reader!)

I don't think it is controversial to say that generating more code, faster, while fewer people read it carefully, piles up technical debt. Ask any developer who has inherited a codebase that was written in a hurry. Early research points the same way: a study from Carnegie Mellon of open-source projects that adopted Cursor found a big jump in development velocity, measured in commits and lines added (yes, really), that was gone within a couple of months. So even by the metrics I dismissed at the start of this post, the gains didn't last. Meanwhile, static analysis warnings and code complexity went up and stayed up. Worse, that added complexity was one of the things slowing those projects down afterwards.

And AI still has to deal with regular code, which means it is under the same limitations developers have always been under. Cruft leads to systems that will have problems down the road.

Some might argue that burning enough tokens will solve that, but at what point is that no longer true? And at what point does the technical debt become so big that it is no longer feasible to deal with it in a safe and reliable way?

The counter-argument tends to be that models will always get better, so there will come a point where this is irrelevant. Because any problem with AI can be solved by adding more AI, right?

I'm personally not sold on the idea that we won't hit a ceiling with AI, but regardless: that is a bet on the future. You're wagering on capabilities that might never exist. For all you know, you might have dug yourself into a hole you cannot prompt your way out of (which is especially bad if the company has invested so heavily in AI that its developers no longer know the code... or maybe can't code at all).

We know the current generation of models has limitations, and future generations will have limitations too. Trusting that the models will eventually get good enough to clean up whatever mess the company has made is a gamble. And if the company does end up in that mess, the initial productivity increase takes a hit too. Since LLMs work with regular code and have to deal with those constraints, they will burn more tokens, take more time and make more errors as the codebase deteriorates. Those gains will get smaller and smaller.

The real risk, though, is the codebase getting so rotten that LLMs can no longer make reasonable sense of it, hitting the limits of their context and "reasoning". Eventually things are so tangled together that the LLM's context (or awareness, if you will) can't keep track of all the complexity, and it starts making mistakes.

One might argue that humans would do the same given an ever-increasing amount of technical debt, and you'd be right. But in this scenario we've opted into decreasing the developer competency that would normally handle these situations, so there are fewer opportunities to even notice a deteriorating codebase.

My argument is not that human developers are perfect. I think they're far from perfect. My point is that automating technical debt generation might also be imperfect and have long-term complications attached to it. We have to wrestle with the idea that the initial productivity gains might be temporary.

Not all productivity is productive

Fine, I hear you. You believe that AI is a productivity increase and that it is a long-term increase. And hey, I'm not saying you're wrong! All I'm saying is that it has yet to be proven. But for the sake of argument, let's assume that is the case.

Now, are there any downsides to increased productivity?

I can think of at least one: we lose focus on what actually matters. We need look no further than website design to see how AI has changed our priorities.

Before AI we were going for clean and minimalistic designs, where visual flair was added with intent. Granted, the actual implementation of this design trend wasn't always perfect and much came down to the individual developer, but the trend was there regardless.

If we contrast this with the current trend, we see visual flair added for the sake of it. Everything that can move does move, even when there's no interaction. Stuff is added because it can be added. Not because it improves the user experience, mind you; I suspect it happens because it looks impressive and is easy to add. Look at junior developers' portfolio websites right now and you'd have a hard time finding one that doesn't shuffle around, light up when hovered, zoom in or out, etc.

But I think we can take it even further. If we assume mainstream AI usage started in 2025, the year Claude Code, Codex and Gemini CLI were released (the most generous starting point, since most AI proponents agree that the models before then weren't good enough), then I must ask: is the productivity in the room with us? That's nearly two years of supposedly supercharged development.

I use a bunch of applications. I use a bunch of websites. I use a lot of software. Yet I do not see the features that actually matter for the core product being added any faster, nor bugs being fixed any faster. I don't see any particular increase in reliability either. Anecdotal? Maybe. But I can't shake the feeling that we claim all this productivity, yet we cannot see it in the services we use... or at least I can't.

Some would say the gains are there, they've just gone into smaller teams rather than more features. More productivity can mean getting the same done with less. But that doesn't really add up either. We're told that we have to use AI to stay competitive, and the way you stay competitive is by building a better product than the competition, not by building the same product with fewer people. If the gains go into reduced headcount, it isn't about forward momentum at all. It's about the bottom line. And most of these companies were profitable before the AI wave, and I haven't exactly noticed my subscriptions getting any cheaper.

What I have seen is the completely desperate rush to push AI into every product that exists (looking at you, Microsoft/Microslop). Just an onslaught of features nobody asked for that add little to no actual customer value. And if there's any productivity gain, I suspect that the gain is spent on frivolous things that nobody actually wants. Stuff that would normally be tossed aside in favour of improving core functionality.

I am a firm believer that limitations can be good. They prevent scope creep, force you to focus on what actually matters and push you towards completion. Sure, too many limitations and you get other problems, but some kind of limitation is necessary.

Take Star Citizen, which has raised more than a billion dollars at this point, yet still hasn't released a finished game. It is still in alpha, and its single-player campaign, Squadron 42, has been pushed yet again, now to 2027. Clearly a near-limitless budget has not resulted in a finished product, and what has been released has been questionable.

We see the same with projects that have no time constraints. Duke Nukem Forever was announced in 1997 and developed under the motto "when it's done". It was done fourteen years later, in 2011, and was panned by critics.

My point isn't that having no limits automatically leads to failure. It's that focus comes from limitations, and when they disappear, focus tends to go with them. I don't really buy the idea that AI removes our limitations, but if it does, I suspect the excess productivity will keep going into things that don't really matter to actual users.

The productivity trap

Productivity can't be bad. More productivity means getting more done, which means more for the customer and more profit. Even better, if we increase productivity enough, we can cut overhead while staying competitive, increasing profit. After all: line must go up!

And honestly, I can't fault the premise. More productivity does in fact lead to getting more done, or getting the same done with less.

We know that we cannot measure developer productivity, but I believe most of us have a sense of it in our day-to-day work. Whether that sense is accurate is a different question, because feeling productive and being productive are not the same thing. We've all had days where we were busy from morning to evening, closed a bunch of tickets and achieved nothing that mattered. Watching an agent churn out code feels like a lot is happening, but "a lot is happening" is not the same as progress. (The developers in the METR study felt about 20% faster with AI, while being measured as 19% slower.)

A lot of people "know" they're more productive, so let's take them at their word. But productivity at what cost?

In this post I've made the basic point that everything comes with tradeoffs. There's no such thing as a free lunch. Offloading more of the thinking and decision-making to AI means less insight for you, and opens up a new vector of errors.

With a compromised understanding of its systems, an organisation ends up lacking institutional knowledge. Answers take longer, mistakes slip through, responsibility mentally drifts to a machine that can't carry it, and the codebase quietly rots. And unlike tokens, you can't just buy more institutional knowledge when you need it.

That's the trap: productivity is the only one of these aspects that's easy to brag about, so it's the one everyone chases, while the rest erode in the background.

So what do we do about it?

My honest opinion is that leaders should let teams figure out how to use AI. Give them the tools they need, but don't do top-down pushes. In my experience, that's where most of the pressure comes from: I recently worked on a project where leadership made it clear that if you didn't use AI, you would no longer be employed there. That's Goodhart's law in action. Make AI usage the target, and you'll get AI usage. Whether you get better software is another question entirely, and pushes like that wear down a culture that has taken a long time to build.

It doesn't even have to be a hard "top-down" push either. If all the projects that gets higlighted within an organisation is AI-related, then that will have a similar effect.

Celebrate the outcomes that is good. Celebrate milestones and achievements. Don't get hung up in specific technologies or processes that got you there.

Teams (and middle-management) should wrestle with tradeoffs. Productivity is worth chasing, but not at any cost. I want people to think beyond "productivity" and also use words like "responsibility", "accountability" and "duty to your users". I want teams that are aware of their overall responsibilities beyond the current sprint.

Finally, I want to challenge the individual developer: what do you bring? If you're one of those who think programming is solved... well... it isn't, but let's assume it is: what do you bring to the table?

You won't "win" by having the best harness. You won't be able to "out-prompt" everyone forever. If being "good at prompting AI" and "having a great setup" is all that sets you apart, then what you bring will diminish in value as tooling around LLMs continue improving. What value does having you have on a team when "prompting good" isn't novel?

My advice would be to build trust, be responsible, create human connections and continue to have a deep understanding of the systems you work with.

My overall advice would be to be wary of chasing productivity without considering the tradeoffs.