Is Software Development at Risk From AI? A Builder's Honest Take

"Will AI replace developers?" is the wrong question, asked anxiously, roughly every week. The hype crowd says software engineering is over. The doom crowd agrees, for different reasons. Both are wrong — but not in the comfortable "nothing will change" way either.

We build software for a living and use AI tools every day. Here's an honest take on what's actually at risk, what isn't, and what to do about it.

What AI is genuinely good at now

Let's be honest about the capability, because dismissing it is as silly as overhyping it. Today's AI assistants are genuinely strong at:

• Boilerplate and scaffolding — the tedious 60% of a feature.
• Translating between languages and frameworks.
• Explaining unfamiliar code and writing first-draft tests.
• Small, well-specified functions with clear inputs and outputs.
• Rubber-ducking a design problem at 11pm when no colleague is around.

That's a real productivity gain — often 20–50% on the right tasks. It is not nothing, and pretending otherwise is how people get left behind.

What AI is still bad at (and why it matters)

The gap between "writes a function" and "builds and runs a system" is enormous, and that gap is where most of the actual job lives:

• Holding a whole system in context. Real software is a web of interacting decisions across services, data, and time. AI works in windows; it loses the thread of why things are the way they are.
• Knowing what to build. Most of engineering is figuring out the right thing to build from vague, contradictory human requirements. AI builds what you ask for — which is rarely what you need.
• Judgement under tradeoffs. Should this be fast or simple? Consistent or available? Built now or bought? These calls require taste and accountability the model doesn't have.
• Debugging the weird stuff. The race condition that happens once a week in production. The bug that only appears at scale. AI is great at textbook bugs and lost on the genuinely novel ones.
• Owning the outcome. When it breaks at 3am, a model doesn't get paged. Someone accountable does.

So what actually changes?

The job changes shape. It doesn't disappear — but the centre of gravity moves:

• From typing to reviewing. Developers increasingly direct and review AI-generated code rather than writing every line. Code review skills, taste, and the ability to spot subtle bugs become more valuable, not less.
• From syntax to systems. Knowing the exact API call matters less. Understanding architecture, data modelling, security, and tradeoffs matters more.
• The bar for "junior" rises. Tasks that used to be a junior's training ground are now done by AI. This is a real problem for how the industry trains the next generation — and an opportunity for juniors who skill up on judgement fast.

The honest risk picture

At risk: developers whose value was purely producing volumes of straightforward code to a precise spec. That work is being automated, and denying it doesn't help anyone.

Gaining value: developers who understand systems, make good architectural and security decisions, translate fuzzy business needs into the right thing to build, and can review and direct AI output critically. These people become more productive and more valuable, because AI amplifies their leverage.

There's also a counter-current people underweight: as software gets cheaper to build, the world wants more of it, not less. Jevons' paradox applies — cheaper production tends to expand demand. More companies can afford custom software; more ideas become viable. The total amount of software being built is likely to grow.

What to do about it

If you're a developer: use the tools — fluency with AI assistants is becoming a baseline skill. But invest disproportionately in the things AI is bad at: systems thinking, security, architecture, debugging, and the human side of understanding what to build. Become the person who decides and reviews, not just the person who types.

If you run a team: AI raises throughput, but unreviewed AI code raises risk. Invest in review discipline and automated security tooling in the same breath as you adopt AI assistants. And think hard about how you'll train juniors when the old training tasks are automated.

If you're a business deciding whether to build: the cost and time to build quality software is dropping. Ideas that weren't viable two years ago are viable now. That's an opportunity — provided you partner with people who bring the judgement the AI doesn't.

The bottom line

Software development isn't at risk from AI. One narrow slice of it — high-volume, low-judgement code production — is being automated, the same way compilers automated assembly and high-level languages automated memory management. Every previous abstraction made developers more productive and more in demand, not less.

The engineers who thrive won't be the ones who resist the tools or the ones who blindly trust them. They'll be the ones who use AI to handle the mechanical work and spend their own attention on judgement, systems, and security — the parts that were always the actual job.