If AI is so good, why do we still need to hire?
It's a question that comes up a lot now. Someone watches a coding assistant produce a working sign-in page in under a minute, and the next thought arrives on its own: if a machine can do that, why am I about to pay for another developer?
It's a fair thing to ask. The tools are good, and they're getting better quickly. Anyone who tells you otherwise probably hasn't spent much time with them. But the question rests on an assumption that doesn't hold up, which is that writing code is the expensive part of building software. It never was.
Typing was never the bottleneck
In more than a decade of building custom software, we've learned that projects rarely run late because someone typed too slowly. They run late because nobody was sure what the software should do in the odd cases. Because the new system had to talk to an old one that nobody fully understood. Because a decision made in week two turned out to be expensive in month six.
Code is where all of that ends up, so it's easy to mistake the code for the work. Really it's a record of hundreds of small decisions. AI has made the recording much faster. The decisions are still there, and someone still has to make them.
What the tools are genuinely good at
Credit where it's due first. A capable developer with a good assistant moves faster than the same developer without one, and the gain is real.
The tools are quick at the scaffolding every project needs: the data classes, the form, the API endpoint that looks like the last ten. They write a decent first draft of unit tests, which removes a lot of the friction that makes people skip tests. They're very good at explaining unfamiliar code, which used to cost a new team member a week of reading. And they're useful for the tedious translation jobs, such as moving code from one framework version to the next.
What those jobs have in common is that the right answer can mostly be worked out from what's on the screen. The trouble starts where it can't.
Where they fall short
Your business isn't in the prompt
Picture something as ordinary as an invoicing rule. On paper it's simple: invoice on the first of the month, payment due in 30 days. In practice, two large customers are billed quarterly because of a deal someone made years ago, one region needs a different tax line, and the finance team fixes a rounding difference by hand every month because the old system never got it right.
None of that is written down anywhere an AI tool can read. It lives in people's heads, in old email threads, in a spreadsheet on someone's desktop. A good developer goes and finds it. They ask the awkward question in the meeting ("what happens when a customer pays half?") and they notice when two people give different answers. An assistant will write a clean, well-organised invoicing module for the rule you typed in, and it will be wrong in exactly the places that matter.
Confident and wrong look the same
The code these tools produce usually reads well. It's tidy, it's commented, it compiles. That is part of the problem, because the mistakes don't look like mistakes.
A date comparison that breaks across time zones. A query that's fine on the test database and crawls once the real table has a few million rows. A call to a library function that sounds right but doesn't exist, or existed two versions ago. An endpoint that checks whether you're signed in but not whether you're allowed to see that particular record.
Catching these takes the same skill it takes to write the code yourself, plus a healthy habit of distrust. So the review work doesn't go away. If anything there's more of it, because more code is arriving, faster.
Someone has to own it
When an order system goes down on a Friday evening, somebody gets the call. That person needs to know what changed, why it was built the way it was, and what they can roll back without losing data. An assistant can help them read the logs. It can't be accountable, and it won't remember why the retry logic was written the way it was. A business needs a person who knows the system and answers for it.
The trade-offs have price tags
Most of the decisions that shape a project are judgment calls with money attached. Build the reporting yourself, or buy a tool? Ship the feature this month on the current data model, or spend two weeks fixing the model first? Which cloud services fit the budget, and which ones turn into a large monthly bill once traffic grows?
Ask an AI tool any of these and you'll get a well-argued answer. It just doesn't know your budget, your deadline, your team or how much risk you can live with, and those are the things that decide the answer.
Real systems are bigger than one file
Assistants do their best work on a single function or file. A real business system is an old database with a few strange tables, three or four outside integrations, a sign-in provider, a deployment pipeline and some scheduled jobs nobody has looked at in a while. Making a change that's safe across all of that means knowing how the pieces fit together. That knowledge is built up over time, by people who work in the system.
So what has actually changed?
Quite a lot. Just not in the simple way the question suggests.
The hard part of the job has moved. Less of a developer's day goes into producing code, and more goes into deciding what to build, reviewing what was produced and making sure it all holds together. That shift favours experience. A strong engineer with AI tools gets noticeably more done, because they can tell good output from bad quickly and they know what to ask for. A weaker engineer with the same tools can turn out a lot of code very fast, and then somebody else spends their week untangling it.
In other words, the tools widen the gap between good developers and average ones. That makes who you hire matter more than it used to, not less. You probably need fewer people whose main job is turning a ticket into code, and more people who can think about the problem behind the ticket.
What to look for when you hire now
A lot of interview questions test things an assistant now does in seconds. Here's what we would ask instead.
Ask them to explain a decision, not recite a fact. Have them walk you through something they built and the options they turned down along the way. Listen for reasons: cost, risk, time, the people who would maintain it. Someone who can tell you what they built but not why will struggle to judge what an AI tool hands them.
Give them code to review instead of a puzzle to solve. Twenty or thirty lines that look fine and hide a real bug, such as a missing permission check or an off-by-one error in a date range. Ask what they think of it. Reviewing code is now a large part of the daily job, and you'll learn more from this than from watching someone solve a textbook puzzle at a whiteboard.
Check that they know the platform under the code. This matters most for cloud roles. An assistant will happily write a configuration that works while leaving a storage container open to the public, or set up a service that costs far more than it needs to. Ask how they would deploy what they built, secure it and keep an eye on the bill.
Ask how they use AI tools, and how they check the output. There's no single right answer. But "I don't use them" and "I use them for everything and it's usually fine" both deserve a follow-up question. You want someone who uses the tools and still reads every line before it ships.
Ask about something that broke. Who noticed, what they did, what they changed afterwards. People who have stayed with their work after launch know things you can't learn any other way, and it's exactly the kind of knowledge AI tools have least of.
Where AI fits on a team
Our view is straightforward. Use the tools for the slow, repetitive parts of the work: the scaffolding, the first draft of tests and documentation, the hours you'd otherwise spend finding your way around an unfamiliar codebase. And keep a named person responsible for every change that reaches production, someone who has read it, understands it and will pick up the phone if it breaks.
Do both and you get the speed without the mess. Lean on the tools alone and the speed tends not to last, because sooner or later someone has to understand what was built.
The short answer
You still need to hire because software isn't mostly code. It's understanding a business, making trade-offs and standing behind the result. AI is a very good tool in the hands of someone who knows the job. It isn't a substitute for knowing the job.
If you're planning a project or growing a team and want a straight answer on where AI will help and where you need people, talk to us.