I keep coming back to a question that's been bugging me for a few months.
A year ago, I could build a basic app in a weekend with some help. Now someone who has never written a line of code can describe an app in plain English and get something that runs by lunch. The login works. The forms save data. The page looks decent. The first time I watched it happen, I was impressed.
Then the question comes up, usually from a client, sometimes from me on a bad day: if the thing works, what am I bringing to the table?
I don't think that question is stupid. I think it's the right one, and I think a lot of developers answer it badly. Some get defensive. Others say "you can't build real software without years of experience," which isn't much help to someone who just watched a demo. So let me try to answer it properly.
A working app is not the same as working software
The gap I keep coming back to is the one between building something and engineering something.
Building means making the thing work once, on the day you show it. Engineering means making it keep working while everything around it changes. Those are different jobs, and they don't get harder in the same way.
Here's what the second job looks like in practice. Someone wants a new feature that touches three tables designed for a different purpose. Traffic doubles after a mention on a podcast, and the query that looked fine in testing now takes four seconds. A payment provider changes its webhook format and sends a notice that nobody reads. A migration has to move a million rows without losing the ones written while it runs. A user says their data shows up in the wrong account, and you have to work out whether the bug is in this release, the last one, or the import script from eight months ago.
None of these are exotic. They're normal for software people actually use. And the first version of the app doesn't solve any of them, however good it was.
I could be wrong about this, but I think most of the real value in software shows up in year two and year three, not in the first two weeks.
What the job actually includes
When people say "developer," they often picture someone typing code. For me, typing is the smallest part. Here's roughly where my time goes.
Understanding the problem. Clients rarely describe the real problem. They describe a feature. A big part of my job is asking why. The "export to Excel" button often turns out to be about an accountant who reconciles payments every Friday. Once you know that, you might build something quite different, or tell the client the button is the wrong answer.
Making decisions that are hard to undo. Which database. Whether two services talk directly or through a queue. How you handle money, time zones, and deleted records. These choices are cheap on day one and expensive on day four hundred. Nobody remembers the moment they picked a database. Everybody remembers the week they had to move off it.
Maintainability. This word gets abused. People hear it and think "clean code," meaning tidy functions and good variable names. Those help, but they're only part of it. Maintainability is also whether tests tell you when you broke something, whether you can see what the system is doing in production, whether someone can read the docs and deploy without calling you, and whether you can change one part without the rest falling over. I've seen beautiful codebases that were impossible to change safely, and messy ones that were easy to work in because they had good tests and clear boundaries.
Performance and load. Finding the slow query before the customer does. Knowing that an N+1 query on the list page is fine with 50 records and a disaster with 50,000. Knowing when a cache solves the problem and when it just hides it until it gets worse.
Security. Authentication is easy to build and easy to build wrong. Authorization is usually where things break. Checking that user A can't see user B's invoice by changing an ID in the URL is a boring test, and it's the kind of gap that gets people sued. Input validation, secrets handling, and not logging card numbers are all unglamorous, and none of them show up in a demo.
Production ownership. When something breaks at 2am, someone has to read the logs, work out what changed, decide whether to roll back or patch forward, and write down why it happened. A lot of software that looks finished has no answer to the question, "how would we even know if this broke?"
AI helps, but only with what you ask
AI can help with every item on that list. It can suggest an index, write a test, draft a migration, or explain a stack trace. I use it every day.
But there's a catch that I don't think gets enough attention. AI generally answers the question you asked, and it won't raise the problems you didn't know to ask about.
Here's a concrete case. Say you tell an AI tool, "fix the bugs in the checkout." It will look around, find things that could be considered bugs, and start changing code. Some of those changes will be right. Some will be unnecessary. A few might alter behavior that was working on purpose, like a rounding rule the accounting team depends on. The tool isn't being careless. It just doesn't know which problem you have, how it started, or what else depends on the code it's touching.
Compare that with, "the invoice total is off by one cent when a discount and tax both apply. Find where rounding happens in the checkout calculation and change only that." The second prompt needs you to know something: that the problem is rounding, that it shows up with discounts and tax together, and that the calculation lives in one place. You only know those things if you understand the system, or if you've looked at the output closely enough to narrow it down.
So the skill isn't only checking what the AI gives you. It's knowing what to ask in the first place. You need to know where the problem probably lives, what symptoms point to which cause, and what a safe change looks like. A vague request gets a broad change. A specific request gets a narrow one. I've watched both happen on the same codebase.
That's why I think the usual "AI suggests, human verifies" framing is only half the picture. Verification matters. But if the human doesn't know what to ask, the AI won't surface the issue, and the human won't know it's missing.
Speed isn't the advantage people think it is
There's a common assumption that vibe coders are faster because they skip the typing. In my experience, typing was never the bottleneck. The bottleneck is knowing what to ask for and knowing when the answer is wrong.
An experienced developer using AI tends to move quickly for a boring reason: they can look at generated code and spot the problem in ten seconds. They know a function will race under concurrent requests. They notice the schema doesn't index the column they filter on. They also know which question to ask next, so the tool doesn't wander through the whole codebase making changes nobody asked for.
Someone without that background can get the same first output. The difference shows up later, when a subtle problem goes unnoticed or a broad "fix" touches things that were fine. Then the fast path turns into days of debugging code nobody fully understands, sometimes with the AI confidently proposing a fix that doesn't fix anything.
So I don't think AI makes everyone equally productive. It amplifies what you already know. For someone with deep knowledge, that's a big gain. For someone without it, it can be a quick way to build something they can't maintain. Sometimes that trade is fine. Sometimes it isn't, and the difference is usually what the software is for and what happens when it fails.
The first delivery is not the whole product
Here's a thought experiment I use with clients.
Two developers build the same product. Developer A delivers in two weeks. Developer B takes three weeks and includes tests, error handling, a deployment setup, basic monitoring, and a short document explaining how the pieces fit.
On launch day, the two products look identical. Same screens, same features, same invoice. If you judge by the demo alone, you might pay A less and prefer A's speed.
Now change a few things. The client wants a feature that touches the core billing logic. Traffic grows tenfold. The email provider goes down. A migration fails on a Sunday night. A vulnerability turns up in a dependency. A feature that worked last month breaks after an update that had nothing to do with it.
Developer A's product will probably survive most of this. But every change takes longer and carries more risk, because there's no safety net and nobody has written down how the parts connect. Developer B's product still takes time, but that time goes into the actual change instead of archaeology.
This is where technical debt stops being a metaphor. A shortcut isn't always wrong. For a prototype you plan to throw away, shipping in two weeks is exactly the right trade. But a shortcut has a cost, and someone has to understand that cost, track it, and decide when to pay it down. If nobody knows the shortcut exists, the debt keeps growing in the dark.
When vibe coding and no-code are the right answer
This is the part I want to be clear about, because it's easy to get wrong in either direction.
Vibe coding and no-code tools are completely fine for a lot of work. If someone needs a landing page to test an idea, an internal dashboard that five people will use to track inventory, a quick script to rename a few hundred files, or a prototype to show investors before they've committed to anything, these tools are often the best choice. They're cheaper, faster, and good enough. Paying someone to design a careful architecture for those things would be a waste of money, and I'd rather say so than make a project more complicated to justify my time.
The question I ask is about consequences, not about how the thing was built. What happens if this breaks? Who gets hurt? Does it touch money, personal data, health information, or anything a customer depends on? How many people will use it, and for how long? If the answer is "not much, and we can fix it on Monday," then a vibe-coded app is probably fine. If the answer involves real money, real users, or a business that will grow, the picture changes. That's where the engineering questions start to matter, and where a tool that only answers what you asked can leave important things unasked.
A useful rule of thumb: the cheaper the failure, the cheaper the build can be. The more expensive the failure, the more someone needs to understand the system before it goes live. That line moves over time, and a prototype that gets real users has crossed it whether anyone planned for that or not.
I want to be fair to developers too. We do overbuild. I've built systems with message queues and service boundaries that one script could have handled. Those choices made me feel like a serious engineer. They didn't make the product better. Complexity has to earn its place, and if I can't explain why a piece exists in one sentence, it probably shouldn't be there.
So the best developer I know isn't the one who writes the cleanest code, and it isn't the one who insists on the most architecture. It's the one who can tell which kind of project they're looking at, pick the level of engineering that fits, and explain the trade-off in plain words to a client who isn't technical.
The example that changed how I explain this
A founder I know built a small online marketplace with an AI tool. Listings, buyers, sellers, checkout. He got it running in a few days and was proud of it. The test checkout worked, so he assumed the payments worked.
What he hadn't checked was that the payment setup was still in test mode. Orders went through on the frontend. Sellers saw "paid" and shipped goods. But no real money was being captured. By the time he noticed, he had lost a sum of money he didn't want to disclose, and he had no clean way to tell which orders were real.
The tool that built the app never warned him, because nobody asked it to. Nothing in the setup would have told him money wasn't moving. He didn't know to ask whether the payment provider was in live mode, and the AI had no reason to bring it up.
He eventually reached a developer who spent an afternoon tracing the payment flow. The fix to the configuration was small. The developer also added a check that compared what was recorded as paid against what the payment provider had actually captured, and wrote a short list of things to verify before going live. Finding the problem was the job, and knowing what to ask was most of it.
I don't tell this story to say vibe coders are reckless. Experienced developers make the same kind of mistake all the time. I tell it because it's the clearest example I have of the gap I'm describing. The product really worked. What it lacked was someone who knew which questions to ask before real money touched it.
So what are developers paid for?
If I had to name the core of it, I'd say judgment, execution, adaptability, ownership, and leverage. Those sound a bit corporate, so here's what I mean.
Judgment is knowing which decisions matter and which don't, and knowing which questions to ask. Execution is turning a clear requirement into software that behaves the way it should. Adaptability is handling the changes that come after launch, which always come. Ownership is being the person who answers when it breaks. Leverage is using tools, AI included, to get more done with the same effort. AI is making some of those cheaper. Judgment and ownership are harder to automate, because they depend on context and consequences.
Code is still part of the job. But I think it's becoming the medium we use to practice those other skills. A carpenter spends most of the day with a saw, but the real work is judgment about wood and joints.
The verification problem
Generating code has become cheap. Checking it hasn't. A function can look right and still be wrong in ways that matter. It can be correct for the case you tested and wrong for the one you didn't. It can work today and break when a dependency updates. It can look secure and still leak data through an endpoint nobody thought to protect.
Reviewing, testing, and verifying still take real effort, and that effort doesn't shrink as fast as generation does. If anything, it grows, because there's more code to check. I think that gets lost when the conversation focuses only on how quickly the first version appears.
Where I could be wrong
I don't know how this plays out over the next few years. Maybe AI gets good enough at testing, operations, and security that most of what I've described gets automated. Maybe the accountability question gets answered by contracts or insurance in ways I haven't imagined. I'd be glad to be wrong about this, because it would mean the software we all depend on gets better.
But I don't see that happening yet, at least not for systems that handle real money, health data, or critical operations. Until it does, I'd rather plan for what I can see.
The title asks a fair question. If AI can produce the working version, the working version alone doesn't justify a developer's rate. Getting software to work is one thing. Keeping it working while everything around it shifts is the part I'd want someone to pay for, and the part I'd want them to understand before they sign anything.