AI / Complex systems / Developer tools
Anyone can produce software now
A working demo has become cheap. A product that strangers depend on hasn't. The gap between the two is real, it is invisible from below, and the people who built the tools say so themselves.
On this page
I keep hearing that anyone can produce software now. Describe what you want, wait a minute, and there it is. The hard part is solved. Developers were the bottleneck, and the bottleneck is gone.
It’s a very common line at the moment. It isn’t a settled view, and plenty of people who build things for a living would argue with it. But you hear it a lot, and you hear it most from people who are about to buy software rather than build it.
And I’m not going to pretend there’s nothing in it. There’s a lot in it. The people who make the tools say it louder than anyone. Boris Cherny, who created Claude Code at Anthropic, told Lenny Rachitsky’s podcast in February that he imagines a world a few years out where “anyone can just build software anytime”. Andrej Karpathy, who gave us the phrase vibe coding (a phrase I can’t stand, but it has stuck), said at a Sequoia event in April that everyone can vibe code anything, and that this is amazing. I code with AI every day. If you’d told me in 1995 that I’d one day describe a feature in a sentence and watch it appear, I’d have asked what you were on, and if I could have some.
But I want to argue with the claim, because it misses out the part of the job I actually do. And if you keep listening, the people making the claim describe that part too. It’s usually in the next sentence.
The dinner and the restaurant
I’m a decent cook. People come back for seconds and they’re not just being polite. But I am not a chef, and I know it. Nobody who cooks well at home concludes that they could run a restaurant.
You know the difference instinctively. A restaurant means the same dinner every night, for strangers, at a price that covers the rent. It means dealing with the supplier who doesn’t turn up, the oven that dies at seven, the table of eight that walks in at ten to closing. The dinner at home is real. It’s just a smaller job than it looks.
Software has the same gap, with one nasty twist. You can’t see it.
If my sauce splits, you can taste it. A demo held together with string looks identical to a solid one. Same screen, same buttons, same satisfying result when you click the thing. The difference only shows when you let the public loose on it. People who have never seen it before, who do things in any order they please, on a phone you didn’t test, with data you didn’t think of. And people who are actively looking for the weak spot in your vibe-coded wonder, because that is their job or their hobby.
Karpathy found this out in public. A few months after he coined vibe coding, he built a real web app that way and wrote up what happened. The prototype on his laptop took very little time. Then came the accounts, the keys, the domain, the payments, the deployment, and he spent most of the project in a browser gluing what he called a monster. His conclusion was that it was not a good idea for anything of actual importance. The dinner was done in an afternoon. The restaurant was the rest.
Nobody can see that from the outside. Often the person who made it can’t either. And the person about to pay for it almost never can.
Three people who can produce software
So let me be more precise about who “anyone” is, because the claim is true for all of them and it means something different for each.
Take my mum. She could tell an AI what she wants and get a program that does it. It’s for her, it does her thing, and it suits her. She’d be the only user. She’d know its quirks, because she was there when they appeared. If it broke on a Sunday, she’d be the only person inconvenienced. Good enough for her own requirements, and I mean that without a trace of condescension. That is a real and useful thing, and until recently it didn’t exist at all. Karpathy’s original post described exactly this and was honest about it: he accepted every change, stopped reading the diffs, and called it not too bad for throwaway weekend projects. Cherny says the same about his own side projects. If nobody else runs it, you can push straight to main.
Then there’s someone technical who isn’t a developer. A sysadmin, a data person, someone who’s written scripts for years and knows what a database is. They can produce something noticeably better than my mum could. It has a login, it has a backup, it doesn’t fall over when two people use it at once. And then they hit a wall they couldn’t see coming. A library stops being maintained. A query that was fine with a thousand rows takes a minute with a million. Something that worked in testing breaks on the one browser the client uses. They’re not stupid. They’ve simply never been there when that particular thing went wrong before. Matt Pocock, who teaches this stuff for a living, puts a number on why: the feedback loop on a strategic mistake is long, and it can take nine months to come back at you. People change jobs faster than that. Their mistakes never catch up with them, so they never learn what the mistake was.
And then there’s a developer with years of watching things fail in front of real users. Not a better typist, and these days not even the one doing most of the typing. Someone who has seen enough variations that the next failure isn’t quite a surprise.
Cherny is the clearest example of this person I know of. He hasn’t edited a line of code by hand since November 2025. Claude writes all of it, twenty or thirty pull requests a day. That is the claim, lived. And in the same breath: he reads every line, a human still approves every change, and the reason is that a lot of people run the program. “You have to make sure that it’s correct.” The hands left the keyboard. The judgment didn’t.
False summits
Here’s the part I find interesting. The gap between the three gets harder to see the lower you stand. My mum can’t see what the sysadmin would do differently. The sysadmin can see some of what the developer would do differently, but only some, because the bits they can’t see are precisely the bits nobody has shown them yet.
Anyone who walks in the mountains knows the feeling. From the valley you see one ridge, and it looks like the top. You climb it, and behind it is another ridge, which you could not see from below. The people on the second ridge can see the valley, the first ridge and the third one. The people in the valley see one ridge and call it the summit. Nobody is lying. They just can’t see what’s behind the thing in front of them.
People reach for Dunning-Kruger here, and I’ll name it once because everyone does. Two psychologists tested students in 1999 and found that the worst performers rated themselves well above average, because the skill you’d need to judge your own work is the skill you haven’t got. Statisticians have been arguing about that chart ever since, and some of the effect is noise. But the everyday version holds up fine, and it isn’t an insult. It’s a description of what it’s like to look at a mountain from the valley.
There’s a quieter finding that fits software better. In 2002, two researchers at Yale asked people how well they understood everyday things, a zip, a flush toilet, a bicycle. Then they asked them to write down how the thing works. Then they asked again. The second rating was always lower. They called it the illusion of explanatory depth: we mistake familiarity with a thing for understanding of how it works, and we only find out when someone makes us explain it.
A working demo is pure familiarity. You’ve clicked through it. You’ve seen it do the thing. Nobody asks you to explain what happens when two people save at once, so you never find out that you can’t. That is why the claim feels so obviously true from the outside, and why it feels so obviously incomplete to anyone who has been paged at two in the morning.
I’ll say this against my own side too. A study last year timed experienced open-source developers working with and without AI tools. They were slower with the tools, and afterwards they believed they had been faster. The tools have moved on since and the authors say so themselves. But the perception gap is the point. Nobody judges this well from the inside, at any height.
You can hear the illusion at work in people who are very good at thinking. In June last year Sam Harris had Daniel Kokotajlo on his podcast to walk through a scenario in which AI systems do the work of professional programmers by 2027. Harris drew the conclusion immediately: so then by definition we have a hiring freeze, or a spike in unemployment among software engineers. Later he put it as a company looking at a new model that is as good as any graduate out of Carnegie Mellon and deciding it is done hiring. Harris is one of the sharpest people in public life. And the step from “the machine writes the code” to “nobody needs the engineers” was, to him, a matter of definition.
His guest didn’t take the step. In Kokotajlo’s own scenario the humans step back from the coding and become managers of the systems that do it, checking the work and deciding what to build. That is how I work now, and it’s not a smaller job. Nobody standing on the upper ridge said the mountain had gone. Someone looking at it from outside heard that it was, and it sounded obvious, because from outside the coding and the software look like the same thing.
Smelling trouble
I wrote a while ago about spending a year as a patient and realising that what senior doctors have isn’t more facts. The junior doctors have plenty of facts, fresher and better organised. What the senior ones have is a library of shapes, built from years of having been in the room when something unexpected happened.
I want to be careful with that comparison here. A broken shop is not a dying patient, and I’d be embarrassed to pretend otherwise. The comparison is about judgment, nothing else.
But the mechanism is the same. Training doesn’t just put information in your head. It gives you the instinct to smell trouble before you can explain why. An experienced developer reads a plan, or a diff, or a demo, and something itches. They can’t always say what. Then they go looking, and it’s the unbounded query, or the file upload with no size limit, or the clever shortcut that will be impossible to upgrade in a year. The itch came first. The explanation came second.
The tools have made this skill more necessary, not less, because the mistakes got quieter. Pocock borrows a distinction from John Ousterhout’s A Philosophy of Software Design: tactical programming is getting today’s feature working, strategic programming is keeping the system easy to change next year. His view, which matches mine, is that the models have largely eaten the tactical part, and they do it well as long as someone holds them inside a sound structure. The strategic part is the itch, and nobody has automated that. Karpathy, after a month of letting agents write most of his code, described the errors as the subtle conceptual ones a slightly sloppy, hasty junior developer would make, and said that for code he cares about he watches the agents like a hawk. Syntax errors announce themselves. Conceptual errors wait. Pocock says it in one line: knowledge has become cheap, and the wisdom has got no easier to learn.
You can’t get the itch from a textbook, and you can’t get it from a prompt. You get it from having been there when that thing went wrong, ideally at some cost to yourself.
Two words that get muddled
People use two phrases for building software with AI, and they describe different activities.
Vibe coding is prompting without knowing how software works, and without any way to judge whether what comes back is right. You describe, you accept, you run it, you describe again. If it looks like it works, it works. For my mum’s program that would be the correct approach. Cherny uses it himself, for what he calls code that’s not in the critical path.
Agentic development is a developer directing an AI and checking its work. The AI writes most of the code. The developer decides what gets written, reads what comes back, and knows what to be suspicious of. Simon Willison drew the line in March last year, a month after the phrase appeared: if the model wrote every line but you’ve reviewed, tested and understood it all, that’s not vibe coding. Karpathy himself, a year after coining the term, retired it for professional work in favour of something with more oversight and scrutiny and no compromise on the quality of the software.
Both people might be sitting in front of the same model, typing into the same box. So the tool can’t be the difference. The difference is whether the person can tell when the output is wrong.
I want to be clear about that, because it would be easy to read this as gatekeeping. Anyone is allowed to build things, and anyone should. The question is what you can know about the thing you built once it’s done.
What “finished” actually means
A finished product has to work for people who weren’t there when it was made. That one sentence hides most of the work.
It has to run on devices you didn’t test. It has to cope with data you didn’t expect, and there is always data you didn’t expect. It has to keep strangers’ information safe from other strangers, and keep doing that after the framework underneath it ships a security fix, and the one after that. Someone has to answer when it doesn’t work. Someone has to be accountable when it fails, and “the AI did it” won’t satisfy anyone who’s just lost money.
And then there’s the part nobody budgets for. Years later, someone still has to look after it. The person who built it has moved on. The model that wrote it has been retired. The thing still has users, the users still have problems, and somebody has to open it up and understand what was done and why. Willison again: most of what software engineers do is evolve existing systems, where the quality and understandability of the code is what matters. Pocock puts it the other way round: tech debt used to be something you lived with in a big codebase, and now you can live with it in a tiny one.
None of that is the demo. The demo is the dinner. All of this is the restaurant. And the thing Willison warned about in the same interview is the thing I see most: a good enough prototype faces pressure to get pushed to production. The dinner gets sold as a restaurant because nobody in the room can tell them apart.
A different category, not a worse one
Nobody says my mum’s little program would be worthless. It’s a very good dinner. It’s just not a restaurant, and nobody should sell it as one.
The claim I keep hearing flattens the two into one word. Software. As if the thing that runs on one person’s laptop and the thing that runs a business were the same object at different sizes. They’re different categories, and the difference is invisible in the demo and painfully visible some months later.
Karpathy said it better than I have, at the same event where he said everyone can vibe code anything. Vibe coding raises the floor. The professional version is about the ceiling. And you are still responsible for your software, just as before.
So where does that leave experienced developers? With an opening, I think, and quite a good one. Harris himself, a year after that conversation, said that if anyone is left standing under the shadow of AI it will be the people with good taste who can point the machines in a direction that makes sense. I’d put it less grandly. For long stretches the AI types better than I do, and I’m fine with that. What it can’t do is stand next to a perfect-looking demo and say, this one will hold and this one won’t. Developers can. Buyers often can’t, and they know it, which is exactly why they go looking for someone who can.