Steve Yegge gets into agentic coding #

Recently I listened to a Changelog podcast with Steve Yegge on agentic coding and vibe coding, and at one point they discuss whether that'll mean the death of junior engineers, and Yegge says it won't.

His argument is that agentic coding and vibe coding drastically enlarge the population of people that can produce software: there are many project managers, usability designers, or data entry folks who don't have the technical skills to write code to help them do their job. But with agentic coding, they can use the agent, or vibe-code their way to some code that works...or at least, seems to. Yegge says that with so much more code and software being produced, we'll need more junior engineers to be reviewing that AI-produced code; we'll need someone with the technical chops to go from "this seems fine and it worked with the few things I tried" to "I reviewed the code, the user's description of what it's supposed to do, and can confirm that this code actually works correctly".

He says "the game of building software is about to head into the crowd".

But in some sense, he's totally wrong: that game headed into the crowd over 40 years ago!

It wasn't large language models trained on staggering amounts of computer code. It was spreadsheets.

...but VisiCalc got there first #

I'm inspired here by De Programmatica Ipsum's issue on spreadsheets.

They point out that spreadsheets are quite plausibly the most common programming environment ever. One could argue that the most common programming language by a mile is spreadsheet formulas, or perhaps even specifically Excel formulas.

The introduction of VisiCalc and computer spreadsheets mirrors Yegge's above description of what AI coding agents are going to do: before, you had a large population who could benefit from being able to produce software/code, but didn't have the technical skills; after, they do because of some enabling technology.

In the late 70s and early 80s, those users -- the accountants and other folks doing quantitative stuff -- would have had to write COBOL or Fortran or C or something similar to do their calculations. Think of this computing taks:

I have a list of numbers. I want to input that into my program, and output the sum, minimum, maximum, and average value.

In, say, C? To get the list into the program, you're likely reading from a file. Then you convert the file data into ints or floats, as some kind of list data structure, and then you iterate over that to get those values. You've got file IO, pointers, loops...it's not trivial.

But now you introduce spreadsheets, and what was previously daunting is now pretty simple: put your numbers into column A, and put things like =SUM(A1:A50) in cell B1. Bam! You've got the sum. Do that three more times and you're done.

Fast forward to 2025 #

Now it's 2025, and you've got, say, UI designers who have a very limited ability with HTML, CSS, and JavaScript. They can't write, say, a nontrivial single-page web app, even a proof-of-concept one to test or iterate on their design ideas.

But now you introduce agentic coding, or vibe coding, and your minimally-technical designer can do that.

The C code from the spreadsheet example now becomes, say, a whole bunch of React code; the SUM, MIN, AVERAGE and such become prompts: "Please make a single-page web app that looks like ... and does ... and when the user clicks here, it does...".

There's a lot of criticism of agentic coding and vibe coding regarding the quality of the code -- but there are billions of spreadsheets out there with bad code, or with code that has unexpected consequences: think of, say, scientists renaming human genes because when you type them into Excel, it does unexpected things with them. Or, during the COVID-19 pandemic, how Public Health England lost testing results because it had them in an Excel file with an insufficient limit on the number of rows. And it's likely you have at some point gotten a spreadsheet from someone else, wanted to change it, and discovered a bewildering chain of formulas and references that don't seem to make sense.

Likewise, going forward, we're going to have billions of one-off bits of software -- each the equivalent of an xlsx file -- with code that works, mostly, almost all the time, but that has some flaws or limitations that are all too easy to miss.

A world without spreadsheets? #

If you think having those billions of one-off bits of software is bad, think about a world without spreadsheets. Would you want to live in that world?

We all want spreadsheets, and we've adapted to a world in which we have spreadsheets with bad code; in which life-and-death decisions may be made based on a buggy spreadsheet; in which spreadsheets are used as a very poor database.

Likewise, I want to vibe-code a one-off webpage or tiny little app to do one little task. And I want other, less technically savvy folks to be able to do the same.

For example, let's think of a medical coder. Let's call her Lisa. Her job is to examine records from medical procedures and "code" or categorize what was done in the procedure so that the hospital can request the correct payment from the patient's insurance. (Put aside, for a moment, the well-deserved criticisms of the flaming disastrous mess that is health care in America.)

Lisa needs to do format the output of her coding slightly different for different insurance systems, and has a lot of knowledge of the subtle details of what different insurance systems demand -- "for an appendectomy, everyone wants it to get code A, except for insurance B, who will reject the claim unless it's coded as C with sub-code D." Lisa has years of experience with this and a staggering amount of that kind of very specific knowledge.

Right now she manually fixes the output for each claim before it gets sent out. This is time-consuming and tedious and results in delays for the hospital to get paid and the patient to get billed and so on.

Now imagine Lisa can write a simple program -- maybe a single-page React app, or even a regular Windows or macOS program -- that will let her type in the codes and specify the insurance company, and it outputs the list of codes she wants, formatted correctly.

Imagine further that insurance company E changes how they do appendectomy coding; Lisa goes back to the chatbot, pastes in her program, and prompts: "please modify my program so that for insurance E, an appendectomy is coded F. Oh, and also, Dr. Jones always writes X when it should be Y. Please change the program so it handles that too."

That sounds pretty good to me. (Of course even better would be a simpler, more sensible, more effective health care system in the United States but HAHAHAHAHA).

Over 40 years ago, we gave an early form of vibe coding to the masses. Now in 2025 we're doing roughly the same.

Isn't this a difference in kind, not of degree? #

One counterargument here is: agentic coding, which can create arbitrary pieces of software, is so open-ended and powerful that it presents a level of risk that makes it qualitatively different from spreadsheets. For us to be convinced that the output from your AI agent works as intended and is reasonably safe is far more difficult than the same thing for a spreadsheet, right?

I'm sympathetic to that idea, but the history of AI and how we think of it offers a useful analogy. For a very long time, there are many things that humans do that we thought were qualitatively different from what computers could do. A difference of kind, not just degree or scale.

"'AI' is whatever computers can't do" #

Start way back, with chess. Being good at chess was considered something unique and special to humans and our reasoning abilities. But then there's Deep Blue and Gary Kasparov in the 90's. But after that, we didn't decide that the AI system running Deep Blue had achieved some genuine human-level cognitive abilities -- we just moved the goalposts!

Then it was Go. Ah, they said, Go is more subtle, complex, and has a vastly bigger state space. So that will be too hard for computers, of course.

Well, then came 2016 and the infamous "move 37" with Lee Sedol and AlphaGo. And again, we just moved the goalposts.

"Wait, but there's still the Turing test. These games are just that: finite, well-defined games, so it makes sense we just need sufficiently powerful computers. But human language and interaction and the Turing tests, that's too open-ended." (Just like agentic coding is too open-ended compared to spreadsheets?)

ChatGPT comes along in 2022, and before long, it seems like we have systems that pass the Turing test: look at all the people who think they've "awakened ChatGPT".

What happened when we got AI systems that pass the Turing test? We just shrugged and moved the goalposts.

We thought that chess, or Go, or human conversation, were all differences in kind from the things that computers could do. But it seems like they all were just differences in scale.

So if you think that the jump from a spreadsheet -- that can be used in literal life-and-death situation, as we saw above -- to your vibe-coded app that could release a virus or wipe your company's key databases is a genuine qualitative difference, you need to explain the above goalpost-moving dynamic, in which at every step we were convinced that some thing really did represent some truly unique attribute of human-level intelligence, and when computers achieved that, we didn't declare that the computers had achieved human-level intelligence, even at that narrow task. We just shrugged and moved on.

Knowing that we moved those goalposts so many times, it just seems we can't blithely compare some VisiCalc spreadsheet that finds an average with Lisa's full-featured medical coding program and declare them to be so truly different; it seems like history teaches us that it really can be just a difference of scale.