Reports of code's death are greatly exaggerated← Steve Krouseview sourceReports of code's death are greatly exaggerated
March, 21 2026
A sufficiently detailed spec is code
begins with this lovely comic:

There is a profound tension here: english specifications intuitively feel
precise until you learn better from bitter experience. (It's all in that facial
expression of the last frame.)

"Everything is vague to a degree you do not realize till you have tried to
make it precise."
– Bertrand Russel

Programming, like writing, is an activity, where one iteratively sharpens what
they're doing as they do it. (You wouldn't believe how many drafts I've written
of this essay.)
AI helps you with this, because it – increasingly instantly and well – turns
English into running code. You can then react to it – "move the button there;
make it bluer" – to get incrementally more precise about what you want.
This is why "vibe coding" is such a perfect phraseology: you stay operating at
the level of your English-level vibes while reacting to the AI-created artifacts
that help you sharpen your thinking.
But, vibe coding gives the illusion that your vibes are precise abstractions.
They will feel this way right up until they
leak,
which will happen when you add enough features or get enough scale. Unexpected
behaviors (bugs) that
emerge from lower levels of abstraction
that you don't understand will sneak up on you and wreck your whole day.
This was Dan Shipper's experience when his
vibe-coded text-editor app went viral, and then went down.
As it turns out, "live collaboration is just insanely hard."

"Live collaboration" intuitively feels like a perfectly precise specification.
We've all used Google Docs, Notion, etc so it feels precisely spec'd. It's
incredibly hard a priori to see what this is not the case.
The only reason that I personally know otherwise is that I tried to add a
collaborative text editor to a product I was working on 10 years ago, and it was
an unexpected nightmare of complexity.
What was hard about it? I don't remember! That's part of the problem! Complexity
can be incredibly boring, unpleasant to think about, and hard to remember all
the details and edge cases. For example, the classic flowchart of how Slack
decides when to send you a notification:

But, this isn't the end of the story either. We are blessed with an extremely
powerful tool to master complexity.
Abstraction
There is a fundamental limit in the human brain. We can only think of 7 (plus or
minus 2) things at a time. So the only way to think about more than 7 things
is to compress multiple things into a single thing. Happily, we can do this
recursively, indefinitely, which is why humans can master unlimited complexity.
That compression step is called abstraction.

The purpose of abstraction is not to be vague, but to create a new semantic
level in which one can be absolutely precise.
— Edsger Dijkstra

For example, Sophie Alpert used clever abstraction to
refactor the Slack diagram to this much simpler one:

This is the best part of programming: coming up with increasingly good
abstractions to help us master complexities. My favorite examples of this are
functional programming concepts, like functional reactive programming, which
I wrote a wonderful essay on.
So yes, collaborative text editors are fundamentally complex, but that just
means that we're continually in search of better abstractions to help us master
complexities, like ReactJS or TailwindCSS did in their respective domains.
AGI
But let's play this out 1, 2, 5, 10, 100 years. AI is getting
better/faster/cheaper at incredible rates, but regardless of when, unless you
believe in magic, it's only a matter of time until we reach the point at which
machine intelligence is indistinguishable from human intelligence. We call that
point AGI.
It may seem like an AGI world is a vibe world. If anyone can afford 100
Karpathy-level geniuses for $1000 / month, why ever trouble yourself with any
troublesome details? Just have your army of Karpathys handle them for you.
This is such a joke to me. This is clearly only something you'd think in the
abstract, before this technology arrived.
If you told me that I had access to that level of intelligence, there is zero
part of me that is going to use it to ship more slop. Are you freaking
kidding?? Of course not.
I think we're confused because we (incorrectly) think that code is only for the
software it produces. It's only partly about that. The code itself is also a
centrally important artifact. When done right, it's poetry. And I'm not just
saying this because I have Stockholmn Syndrome or a vested interest in it – like
a horse jockey might in the face of cars being invented.
I think this is a lot clearer if you make an analogy to writing. Isn't it
fucking telling that nobody is talking about "vibe writing"?
We're not confused with writing because there's nothing mystical about
syntactically correct sentences in the same way there is about running code.
Nobody is out there claiming that ChatGPT is putting the great novelists or
journalists out of jobs. We all know that's nonsense.
Until we get AGI. Then, by definition, machines will write amazing non-slop and
it'll be glorious.
The same exact situation is true for coding. AI produces (increasingly less)
shitty code. We all know this. We all work around this limitation. We use AI
in spite of the bad code.
As Simon Willison says,
AI should help us produce better code.
And when we have AGI this will be easy.
When we have AGI, the very first things we will use it on will be our hardest
abstraction problems. We will use it to help us make better abstractions so that
we can better understand and master complexity.
You might think the need for good code goes away as AIs get smarter, but that's
like using ChatGPT to write more slop. When we get AGI, we will use them to make
better abstractions, better collaborative text editor libraries, etc.
For example, my favorite success story with Opus 4.6 was that it helped
me with my dream full-stack react framework for Val Town. It one-shot solved
my list of unsolved problems
that I had with getting React Router 7 to work full-stack in Val Town. The
result is my nascent vtrr framework.
I'm particularly proud of this 50 line full-stack react app demo in
a single file:

If you know of any other snippet of code that can master all that complexity as
beautifully, I'd love to see it.
Reports of code's death are greatly exaggerated
It seems like 99% of society has agreed that code is dead. Just yesterday I was
listening to podcaster Sam Harris of all people confidently talking about how everyone agrees
coding is dead, and that nobody should learn to code anymore.
This is so sad. It's the same as thinking storytelling is dead at the invention
of the printing press. No you dummies, code is just getting started. AI is going
to be such a boon for coding.
I have so much more to say on this topic, but this essay is already 3x longer
than I wanted it to be. I'll stop here and leave you with some of my favorite
quotes on formalism.

Instead of regarding the obligation to use formal symbols as a burden, we
should regard the convenience of using them as a privilege: thanks to them,
school children can learn to do what in earlier days only genius could
achieve.
When all is said and told, the "naturalness" with which we use our native
tongues boils down to the ease with which we can use them for making
statements the nonsense of which is not obvious.
– Edsger W.Dijkstra,
On the foolishness of "natural language programming"

There are two ways of constructing a software design: One way is to make it so
simple that there are obviously no deficiencies, and the other way is to make
it so complicated that there are no obvious deficiencies.
–
Tony Hoare,
h/t Paul Buchheit

The quantity of meaning compressed into a small space by algebraic signs, is
another circumstance that facilitates the reasonings we are accustomed to
carry on by their aid."
– Charles Babbage, quoted in Iverson's Turing Award Lecture, quoted in
Succinctness is Power by Paul Graham
precision · abstraction · ai · coding

Steve Krouse’s essay, “Reports of Code’s Death Are Greatly Exaggerated,” presents a compelling argument against the widespread notion that coding is becoming obsolete, particularly in the face of advancements in Artificial Intelligence. Krouse contends that code, and the process of its creation, remains fundamentally vital, arguing that it’s not simply about producing software, but about mastering complexity through abstraction—a skill that will be increasingly crucial with the rise of AGI.

The core of Krouse’s argument hinges on the tension between intuitive specifications and precise code. He illustrates this with Bertrand Russell’s observation that “everything is vague to a degree you do not realize until you have tried to make it precise,” highlighting the inherent difficulty in translating abstract ideas into executable code. This struggle is exemplified by the “vibe coding” phenomenon—a tendency to rely on imprecise, intuitive vibes when working with AI-generated code—which inevitably leads to unexpected errors as complexity escalates. The author draws upon Dan Shipper’s experience with his viral, then-failed, text editor to demonstrate the risks of overly simplistic, vibe-driven development.

However, Krouse posits that the very challenges of code creation are a strength. He emphasizes the importance of abstraction, citing Edsger Dijkstra’s assertion that “the purpose of abstraction is not to be vague, but to create a new semantic level in which one can be absolutely precise.” Through abstraction, humans can manage complexity by creating layers of simplified representations, enabling them to think about a system at a higher level of detail. Sophie Alpert’s refactoring of the Slack diagram serves as a prime example of this process.

Krouse further anticipates the arrival of Artificial General Intelligence (AGI), arguing that it will not render coding obsolete, but instead, shift its focus. He suggests that AGI will be instrumental in helping us to create even more sophisticated abstractions, allowing us to tackle increasingly complex problems. He playfully dismisses the notion that AGI will simply produce flawless code, likening it to assuming novelists will be replaced by AI, advocating instead for a collaborative approach where humans and machines work together to refine abstractions.

The essay champions a pragmatic approach to coding, illustrating it with examples like the Opus 4.6 framework that solved Krouse’s challenges with React Router 7 in Val Town. This single-file, fifty-line React app demo underscores the benefit of focusing on well-defined abstractions to streamline development. Krouse draws on quotes from Edsger W.Dijkstra and Tony Hoare to emphasize the importance of simplicity and logical design, advocating for a deliberate, thoughtful approach to coding. The use of formal symbols, as highlighted by Charles Babbage, and the value of succinctness, as articulated by Paul Graham, further underscore the necessity of precision and rigorous thought.

Ultimately, Krouse’s argument is a testament to the enduring value of code’s ability to represent and manipulate complexity. He asserts that code’s utility will not diminish with the rise of AGI, but will instead evolve to become a cornerstone of a new era of intelligent systems, driven by our continued need to master complexity through ever-more-refined abstractions.