The Tenfold Tunnel Vision

The universe ends in about 10^10^120 years from now. It doesn’t really end, according tho the Big Chill theory; rather, it will reach an equilibrium state at that time, where nothing happens anymore (to put it in simple words).

What made me think of that? Oh, right: It was the popular claim that AI assistance in software development leads to a tenfold productivity increase. Does it? I have my doubts.

Projects are more than coding

The first question that pops up is, why tenfold? When I look at my own vibe-coded side projects, I experience an almost infinite increase of productivity with each of them. If you don’t believe me, here’s the math:

  • Each project took a few minutes of prompting and a few minutes of bot work to reach the first prototype stage. From there, accumulated work is counted in hours, in the low single-digit range. (I’d estimate 2 hours on average.)
  • Without bots, I wouldn’t have written any of these projects until the end of the universe.

So: 10^10^120 years / 2 hours on average = almost infinitely faster. Quod erat demonstrandum.

My side projects aren’t representative, of course: An idea pops up in my head, I think about the implementation, turn this into a prompt, and let the bot ruminate. In a sufficiently large project, coding is but a small part of overall project work. Time goes into planning, talking to stakeholders, deciding and agreeing on the architecture, setting up environments, writing code, testing code, integrating code, writing technical documentation, writing user documentation, and so on.

What do LLMs accelerate? Coding. That’s what they’re strong at. They can’t take over all the planning and the conversations, because these aren’t algorithmic tasks. They are good at technical testing but not at testing whether the code meets the intents. They can’t evaluate user experience because they have no taste. All of this still requires manual work.

The “tenfold productivity increase” claim is a tunnel vision. It looks legitimate if you only look at the coding phase, but it falls apart when taking on a bird’s view.

The bottleneck just moves

Okay, writing code is just one of many tasks in a project, but obviously, it’s THE bottleneck, right? Manual coding is slow, and it’s error-prone. This may be true when looking at the pure development phase (except for high-functioning developers). But once the coding bottleneck is removed, the next-slowest activity in the development cycle becomes the new bottleneck. Usually, it’s the review and test activities. Coding bots produce PRs within minutes and then wait for human reviews and approvals.

For documentation, it’s the same. A draft is ready within minutes, but the review needs hours—particularly for technical documentation, where a small shift in wording can distort or completely change the intended meaning.

I’m well aware that autonomous end-to-end software development and maintenance is already seen in the wild. The software built this way is not particularly high-risk software, though: Mostly games or productivity software (see the ArtCraft Suite as an example). I have yet to come across high-stakes software that is involved in critical business operations or even controlling critical infrastructure (but please send me examples if you come across any).

My point is, as long as humans are still involved, and be it only for intervening, the x-fold productivity increase remains made up.

We can’t have it all

Autonomous code writing, autonomous testing, stable software over an extended period: pick two.

Even with the wild progress in agentic coding made in 2026, humans are still a critical success factor. We can choose to pass coding or review to the bots, but not both.

Yet, at least we have the Gopher advantage. Go is incredibly well-suited for AI-assisted work. Just listing a few Go advantages:

  • Quick turnaround times: A compile phase takes seconds to minutes, not minutes to hours. The code-test-deploy flow is fast.
  • Locality: Code does what it says. A + sign is a + sign; it can’t change its meaning from an operator overload that happened five inheritance levels above and seven source code files apart. Both human brains and bots appreciate this.
  • Built-in testing: An established, language-native unit test harness is much easier for an AI to learn than a multitude of third-party testing frameworks that other languages need.
  • A rich public body of open source code since 2011: AI needs plenty of code to learn from. Go has been designed as a team-focused language from the very beginning; this pays off today in clear, idiomatic code seen in many open source projects. (I’ll discuss the legal and ethical implications of this in another article; it’s not a Go-specific issue but affects all open source projects alike.)

…and probably more. But you get the point: Bots have an easy time with Go. Whenever I ask Opus 5.5 to write something, it produces stable, bug-free code most of the time; the usual “bugs” are of the kind “you did not understand what I want.” I can review every PR and point the bot at wrong or silly code (and I do need to do so more regularly).

I could also go the opposite way and have the bot write or extend tests for me while I write code against these tests, then have the LLM review my PR.

Studies indicate that this kind of human-AI cooperation can actually improve output in terms of speed and/or quality. Two interaction models seem to stick out: the centaur and the cyborg. One draws clear borders between human and AI tasks, the other describes a fine-grained intertwining of human and AI work.

So while tenfold productivity is clearly an AI myth, thoughtful delegation of selected tasks to LLMs can improve throughput, or quality, or maybe both. Critical supervision by humans isn’t optional at this point, and I doubt it will become optional in the foreseeable future.


Em-dashes proudly hand-crafted.