Take It Slow: A Letter to Developers Told to Use AI for Everything
The future of custom software for anything is now. If you need a tool for your small business, your family budget, your neighborhood association, or your weird hobby, you can have it by this evening. You describe it, an agent writes it, and it mostly works.
So the value of software is now close to zero, and I don’t say that as a provocation. Code used to be expensive because producing it was slow, scarce labor. That scarcity is gone. When anyone can produce a working app in an afternoon, the app itself stops being the thing worth paying for.
Everyone says this as if it were the end of the story. It is the beginning.
What gets cheap and what gets expensive
Of course, there's a difference between an app that works on your laptop and one that can reliably handle a million customers. The second is still expensive. The interesting part is where that expense goes when producing the code becomes almost free.
When production becomes nearly free, value moves to whatever is still scarce. Four things are still scarce:
- Someone who knows what should be built, and why.
- Someone who understands how the pieces fit together and where they will break.
- Someone who can tell whether what the agent produced is actually correct, safe, and maintainable.
- The one who can look at all of it and say “no, we’re not shipping this.”
Coding, architecture, security, and product management are not becoming irrelevant. They are being unbundled from typing, and the typing was always the cheapest part. An agent can generate ten thousand lines of plausible code in minutes. It can write tests, review its own output, and suggest security improvements.
It can also be confidently wrong about all three.
And it cannot be held accountable for them. It does not know your threat model. It will not lose sleep when the thing leaks data. Someone who understands the system has to stand behind every line, and the value of that person is skyrocketing.
Whether companies will be willing to pay for it is another matter. History offers plenty of examples of valuable people being paid rather poorly.
To the young developer
If you are early in your career and your employer is asking you to use AI for everything “to increase your performance,” I hope, and I truly hope, that you will take it slow.
Give yourself time to learn the basics. Understand what you are writing, or at least what the agent is writing on your behalf. Vibecoding is easy. I do it myself, and I’m not an idiot about it. I prototype, and I keep it local. I treat the output as a sketch, not as a building.
There's nothing particularly noble about spending three days writing something an agent can produce in ten minutes. I have better things to do with my life, and I suspect you do too. But I know enough to be suspicious of something that works on the first try. That suspicion took years to acquire.
Consider what happens when you skip that step. Say I decide to “improve” the software on my TV, or flash something clever onto my router, because an agent told me it would look better and run faster. I haven’t read the code, and I don’t know what ports it opens or what it exposes. Now my entire home network is vulnerable to anyone who walks past my window with a free app like Fing on their phone, or a laptop running Nmap, scanning for open doors. It takes thirty seconds, and I handed them the key because I couldn’t be bothered to understand what I was installing.
Now replace my router with a company server. Replace my television with a customer database. Same ignorance. More people paying for it. That is the real risk of this era.
The risk is not that AI writes bad code. We've managed to produce plenty of that without assistance. It is that a whole generation of builders will lose the ability to tell whether the code is bad.
Your manager wants more output. The company is paying your salary and has every right to expect results. You want to keep your job, receive a good performance review, maybe get promoted. Everyone has reasonable expectations.
An agent fixes in ten minutes a bug that might have taken you two days to understand. You close the ticket and move on. Your manager is happy. You're happy. The company has saved money. What nobody has measured is what you didn't learn during those two days.
Do this often enough, across enough companies, and we may discover that we've become exceptionally good at producing software and remarkably bad at understanding it. Nobody decided to stop training engineers. We just made learning look like a productivity problem.
Validation is a muscle, and you build it by doing the slow, boring, manual work first: reading, breaking things, fixing them, and understanding why they broke.
What the slow way taught me
It took time, and I made mistakes. Along the way I arrived at a few principles that now govern my professional life, and I think they matter more, not less, when agents do the typing:
I value people, but I don’t substitute consensus for decisions.
I value process, but I don’t preserve processes simply because they exist.
I value planning, but I don’t mistake plans for reality.
I value delivery, but I don’t confuse completing tasks with creating value.
I value continuous improvement, but I don’t disrupt functioning systems unnecessarily.
Notice what these have in common. Each one is a refusal to let a proxy stand in for the real thing. Consensus is a proxy for a decision, and a process is a proxy for quality. A plan is a proxy for reality, a completed task is a proxy for value, and constant change is a proxy for improvement.
AI agents are proxy machines. They produce the appearance of progress at industrial scale: tickets closed, features shipped, tests green. If you cannot tell the proxy from the thing itself, you will drown in output and starve for outcomes. The people who can tell the difference are the ones who will matter.
The value of knowing
So here is where I land. The value of software is heading towards zero, and that is good news. It means nobody has to be gatekept out of building the tools they need. It means the small shop, the clinic, the village, and the kid in a bedroom can all have software shaped to their lives instead of renting one-size-fits-all products from someone else’s roadmap.
But there is a strange possibility hiding inside all this progress.
We may end up with more software than ever, built by people who understand less and less of what they've produced. The experienced engineers will continue to review, correct, and approve it. For a time.
Then they'll retire. The people replacing them will be the developers we've spent years encouraging to skip the difficult parts. Perhaps AI will be good enough by then to compensate for that loss. Perhaps it will be better at validating software than any human engineer. I wouldn't bet against it.
But that's a prediction, not a reason to abandon learning today.
Zero-cost software does not mean zero-cost responsibility. Someone still has to understand the architecture, secure it, and decide what is worth building in the first place. That work is more valuable than ever, and it can’t be skipped, only learned.
So build freely. Prototype wildly, and keep it local. But take your time with the basics, because in a world where everyone can generate code, the scarce skill is knowing when not to trust it.