So Much Productivity; No Product
So Much Productivity; No Product
Tags: opinion technology ai developer-culture silicon-valley
Author: Markus Maiwald
Date: March 15, 2026
The Shower That Solved Everything
There was a time when the hardest problem in software was a bug you couldn’t see.
You stared at the screen until your retinas burned. Then you stood up, walked to the shower, and let hot water drown the noise. Fifteen minutes of not thinking. Fifteen minutes of letting the warmth empty your skull – letting the subconscious chew on what the conscious mind could not crack. And then – somewhere between shampooing and staring at the tile grout – the answer appeared. Fully formed. Uninvited. Beautiful.
Ask any veteran programmer. They know the feeling. The soothing monotony of running water empties the foreground – and the background process – the one you cannot see or control – delivers the insight that six hours of staring at a debugger could not produce. The Unterbewusstsein does its best work when you stop feeding it instructions.
That shower was the most productive part of your day. Not because you were coding. Because you had stopped.
The problem was never the typing. The problem was knowing what to type. The shower worked because it forced a constraint the screen could not: it made you stop generating and start thinking.
That constraint is now extinct.
The Faustian Compile Cycle
A developer in San Francisco leaves a party at 9:30 on a Saturday. Not drunk. Not tired. He wants to get back to his AI agents. Half the room understands. The other half is already checking on theirs from the bathroom.
This is not discipline. This is withdrawal management.
The condition has a name now: Token Anxiety. The persistent, rational fear that while you sleep, someone else’s machine is shipping. Every week a new benchmark drops that makes last month’s workflow feel paleolithic. Context windows double. Inference gets cheaper. The competitive floor rises while you brush your teeth.
The anxiety is rational – which is why it sticks.
The old Bay Area had a vibe of opportunity. Come here – build something – change the world. The new Bay Area has the vibe of a treadmill accelerating under your feet. The energy has inverted. It is no longer “I get to build.” It is “I must keep building – or I will be replaced by someone who never stops.”
People are spending a thousand dollars a day on API tokens. They stay sober at parties because one drink might cost them thirty minutes of morning sharpness. They replace Netflix with Claude Code. They lie in bed calculating what they can spin up before unconsciousness takes them.
Reading a novel feels indulgent. Watching a film without a laptop open feels wasteful. The voice in the back of their skull whispers: something could be running right now.
This is not productivity. This is a pathology wearing productivity’s uniform.
The Copypasta Paradox
A senior engineer on our team – someone who has spent decades building protocol-level abstractions in Rust – recently spent a weekend refactoring legacy code. Real architectural work. The kind that requires holding an entire dependency graph in your skull while you reshape the joints between modules. Not the kind of work you can delegate to an AI model – because the model has no concept of why the system is shaped the way it is.
Midway through, he surfaced with an observation that has been rattling in my head since:
“These AI parrots copy-paste code for you – but this isolates developers further. You do not like a feature in git? You just write a new git. This is philosophically different from what computer science was for the last seventy years.”
He is correct. And the implications are worse than he stated.
For seventy years, computer science operated on a principle of accumulated abstraction. You did not rewrite the filesystem every time you needed to store data. You learned the filesystem. You understood its constraints. You built on top of it. The accumulation of shared understanding was the entire point – it was how individual effort compounded into collective capability.
AI-assisted coding inverts this. The machine optimizes for works now over fits the system. It produces code that solves the immediate problem with zero awareness of the architectural context it lives in. Every output is an island. And because spinning up a new island is now trivially cheap – the incentive to understand the continent disappears.
The ecosystem fragments. Not because the tools are bad – but because the tools remove the cost that previously forced coherence. When writing a new version-control system was an eighteen-month commitment – you damn well made sure the existing one could not do what you needed first. When writing one is a four-hour vibe-coding session – why bother learning the old one?
This is not progress. This is entropy wearing a ship-fast t-shirt.
Ten Thousand Lines of Nothing
Here is the confession that should terrify every founder reading this:
You can produce ten thousand lines of code in a single day now. Easy. Trivially. The machine does not tire. It does not argue about architecture. It does not demand code review. It just generates.
And none of it means anything.
Ten thousand lines is not a product. It is not a solution. It is not even necessarily correct. It is raw output – the digital equivalent of a factory producing car parts that fit no car. The volume is staggering and the value is approximately zero – until a human with genuine understanding assembles it into something that solves the right problem.
The old constraint – the one that made you selective – was a feature, not a bug. When coding was slow, you could not afford to pursue every idea. You had to choose. You had to think about which problem actually mattered before you spent three months building the solution. That forced selection was the entire discipline of engineering.
Now you can have four ideas spinning simultaneously – all of them in the crappiest version of themselves – all of them generating work at an exponential rate. The backlog grows faster than the output. The prompting cycle is longer than a Rust compile. You are not building; you are babysitting.
The programming was never the problem. Solving the right problem was the problem. And now we have given ourselves the power to solve the wrong problem at ten times the speed.
The Inversion Nobody Talks About
There is a structural shift underneath the anxiety – and it is not the one the VCs are selling.
The narrative says: AI makes developers 10x more productive. This is technically true in the way that a firehose makes you 10x more hydrated. The volume is there. The precision is not.
What actually happened is that the bottleneck moved. It moved from execution to judgment. From typing to thinking. From “can we build this?” to “should we build this?” The shower insight – the one that used to arrive unbidden after you stopped coding – was always the real product. The code was just the delivery mechanism.
And here is the part that should make every Token Anxiety sufferer pause: the new bottleneck cannot be automated. Judgment is not a prompt. Architectural vision is not a context window. The ability to look at four possible directions and choose the one that compounds – that is not a skill the machine has. It is not a skill the machine is close to having. It is the one thing that still requires the wet computer between your ears – and you are poisoning it with sleep deprivation and token-count anxiety.
The people who will win the next decade are not the ones running agents at 3 AM. They are the ones who still take showers – who let the hot water empty their mind – who trust that the subconscious will deliver what the terminal cannot.
The Speed Multiplier (Used Correctly)
Let me be precise about what I am not saying.
I am not saying AI coding tools are useless. I am not a Luddite pining for the days of Vim and righteous suffering. We use these tools daily. They are force multipliers of extraordinary power – when the human remains the architect.
The deep refactoring work that senior engineer spent his weekend on? AI cannot do that. The structural thinking that decides which problem to solve? AI cannot do that. The discipline to say “this idea is not worth pursuing” when the machine makes pursuing it free? AI especially cannot do that.
But the boilerplate around those decisions? Let the parrot handle it. The repetitive test scaffolding? The parrot. The wire-format serialization that follows a spec you already wrote? The parrot.
The correct ratio is not “AI writes everything and I supervise.” The correct ratio is: I architect; AI executes; I verify. The thinking remains human. The typing becomes mechanical. The shower stays sacred.
What does this look like in practice? An eighteen-month manual project becomes four months with AI and proper planning and design. Not four hours. Not four days. Four months – because the planning and design phase does not compress. It should not compress. It is the phase where the actual value gets created.
Anyone telling you they compressed that phase is lying – or shipping garbage they have not yet discovered is garbage.
The Uncomfortable Truth About Public Ledgers
One more observation – tangential but connected.
I become more convinced with every passing week that public blockchains are mostly theater. Useful for one thing: anchoring. Timestamping. Proving that something existed at a given moment. Everything else – the smart contract platforms – the DeFi stacks – the governance tokens – is a solution in search of a problem – and AI is accelerating the irrelevance.
When you can spin up a vibe-coded DeFi clone in an afternoon – the moat disappears. When every chain’s “unique innovation” can be replicated by a sufficiently motivated agent with API access – the value proposition collapses to the only thing that cannot be copied: the anchor. The irreversible proof of work. The timestamp that no machine can forge.
This connects to the broader thesis. The things AI cannot replicate are the things that matter: judgment, architectural vision, irreversible commitment, the discipline to choose the right problem. Everything else is converging toward zero marginal cost – and building your identity around the zero-cost layer is a strategy for obsolescence.
The Prescription
Stop running agents while you sleep. Your unconscious mind does better work than Claude Code when you let it.
Stop measuring productivity in lines of code. A surgeon’s productivity is not measured in incisions per hour. It is measured in patients who walk out alive.
Stop optimizing for speed when you have not yet optimized for direction. A missile that travels at Mach 5 toward the wrong target is not a weapon. It is expensive wreckage.
Take the shower. Read the novel. Leave the party at midnight instead of 9:30 – and have one drink – because the conversation you have at the bar might contain the insight that no amount of token-burning will produce.
The coding was never the problem.
Solve the right problem. Then let the machines type it for you.
Markus Maiwald is the founder of Libertaria – a sovereign protocol stack for decentralized identity and economic coordination. He writes from Budapest – where the Danube does not care about your token budget.