Engineering leaders demand systems design skills as AI coding assistants produce mounting technical debt
Tools like GitHub Copilot promise productivity gains, but companies discover that AI-generated code works brilliantly in clean systems and catastrophically in messy ones
Kin Lane has watched technology evolve for 35 years—from mainframes to mobile, through the dot-com crash and the cloud revolution. Ask him about the current state of software development, and his answer stops you cold: "I don't think I have ever seen so much technical debt being created in such a short period of time."
The culprit sits in millions of developers' taskbars. GitHub Copilot reached 20 million users this year. Ninety per cent of Fortune 100 companies now deploy AI coding assistants. Some 63% of professional developers use AI to write code, with another 14% about to start. Companies crow about 40% productivity gains and feature delivery that once took weeks compressed into days.
But the celebration masks a crisis. The same tools accelerating development are silently poisoning codebases, widening the gap between well-run engineering organisations and everyone else, and forcing an uncomfortable reckoning with how we actually build software.
The great divergence
Here's what nobody expected: AI coding tools don't lift all boats. They're creating winners and losers at a pace the industry has never seen.
Companies with clean, well-architected systems are soaring. Those with messy legacy code are discovering that AI doesn't navigate complexity—it multiplies it.
GitClear analysed 211 million lines of code changed between 2020 and 2024. What they found should alarm every CTO: code blocks with five or more duplicated lines increased eightfold in 2024 alone. Copy-pasted code jumped from 8.3% to 12.3%. Meanwhile, refactored code—the hallmark of healthy systems—dropped sharply. AI-generated code churns 41% more than human-written code, requiring substantially more fixes before it's production-ready.
Google quantified the trade-off: 25% more AI usage speeds up code reviews and documentation but cuts delivery stability by 7.2%. Most developers now spend more time debugging AI output than they save by using it.
The pattern is clear. AI coding assistants dramatically widen the velocity gap between disciplined and chaotic development. Clean architecture with clear interfaces lets AI fly. Tangled legacy systems cause it to crash. The penalty for technical debt just got exponentially steeper.
One engineering consultancy put it starkly: companies with high-debt codebases can barely use AI tools at all. Those with low-debt systems are leaving them behind.
What CTOs actually want now
The hiring earthquake is already underway, though not quite as predicted.
"I'm beginning to prioritise system design above everything else," one CTO explained in a recent survey. "AI eliminates mundane coding. What developers need now is the ability to design scalable, flexible systems. AI can write code. It cannot think about how systems interact at scale."
Jason Hishmeh, a CTO and technology investor, is blunter. "The real value moved away from writing code. Developers spend their time debugging, integrating, making architectural decisions. We look for people who think in systems." His company now tests candidates differently: not coding challenges, but real-world scenarios about scaling CRM modules or reducing load times during peak usage.
The shift appears across job postings. Sixty-five per cent of technology leaders would now choose an AI-enabled developer with two years of experience over someone with five years but no AI skills. But here's the twist: they're not hiring "prompt engineers". They want critical thinkers who can spot when AI is confidently wrong.
Multiple CTOs stressed this point. AI provides confident, incorrect answers constantly. The developers they value can look at generated code and identify the problems, not just accept whatever appears on screen. One called it "healthy scepticism"—the ability to doubt the machine.
This is architectural thinking, not faster typing. And it's becoming the price of entry.
The brutal junior developer market
Whilst experienced developers adapt, recent graduates face a bloodbath. Software developer postings have collapsed 70% from their 2022 peak. Entry-level roles specifically dropped 60%. Computer engineering graduates face 7.5% unemployment—double the rate for nursing graduates, higher than the overall economy.
Matt Garman, chief executive of Amazon Web Services, calls predictions of AI replacing junior developers "one of the dumbest things I've ever heard". His argument is simple: "How's that going to work when ten years from now you have no one who's learned anything?"
But Marc Benioff disagrees. Salesforce paused engineering hiring in late 2024, citing AI productivity gains. A survey of 500 technology leaders found 72% plan to cut entry-level hiring whilst 64% increase investment in AI tools.
Here's the paradox nobody's solved: architects learn by doing foundational work. You write boilerplate, debug edge cases, wrestle with unit tests. Pattern recognition develops through repetition. But AI now handles exactly those tasks. If the machine generates the code, what does the junior developer actually learn?
Some companies experiment with new approaches—mentoring focused on systems thinking rather than syntax, evaluating AI output instead of writing from scratch. Whether you can train architectural judgment without building foundational skills remains an open question. The industry is running the experiment in real time, with a generation's careers at stake.
What's actually changing
The popular story frames this as a pendulum swinging back to 1990s waterfall development—big specifications, architecture diagrams before code, bureaucratic planning. That's wrong.
Engineering leaders aren't abandoning Agile. They're discovering it requires more discipline, not less, when AI generates thousands of lines in seconds.
The Agile Manifesto championed "working software over comprehensive documentation" to kill the bloated specs and 18-month timelines that paralysed development. That worked brilliantly. But the 2025 challenge isn't getting software to work. It's keeping working software maintainable six months later.
The economics are brutal. Companies waste 23-42% of development time addressing technical debt, according to CodeScene research. Engineers spend a third of their time on average dealing with shortcuts from the past. Forrester predicts 75% of technology leaders will face severe technical debt by 2026.
What's different now: iteration without architectural guardrails becomes catastrophically expensive when AI can generate code at machine speed. The successful companies treat AI as a powerful amplifier that requires disciplined engineering, not a replacement for human judgment.
The organisations with 90% adoption and positive outcomes share a pattern: structured training, clear quality standards for AI code, strong automated testing, feedback loops that improve prompting. They measure productivity by outcomes, not lines of code. They understand that volume isn't quality.
Why modularity suddenly matters
Architecture trends in 2025 aren't about new ideas. Event-driven architectures, modular monoliths, composable systems—these concepts have existed for years. They're surging now because AI exposes which systems are actually well-designed.
Clear module boundaries let AI generate coherent code. Spaghetti architecture causes AI to generate more spaghetti. Microservices, clean architecture, domain-driven design—concepts dismissed as buzzwords—suddenly prove their worth. AI amplifies good decisions and bad ones equally. The difference is magnitude.
One consultancy's advice captures the shift: build a system of well-defined modules that robustly model your domain. Do feature work on top of that foundation with maximum AI leverage. When legacy code is too risky to refactor directly, use strangler fig patterns to build clean modules that AI can work with.
InfoQ's latest architecture report notes that whilst large language models are everywhere, architects increasingly focus on designing systems that accommodate them without sacrificing quality. This includes considering that citizen developers will use AI tools in unintended ways, potentially accessing APIs never meant for non-professionals.
The insight: AI doesn't need new architectural patterns. It needs the discipline to execute existing patterns properly. The industry talked about clean architecture for years. Now the bill comes due for those who ignored it.
The uncomfortable truth
Software development isn't experiencing a simple pendulum swing. It's confronting a truth that was always present but easy to ignore: speed without structure never worked. Human developers just moved slowly enough to catch problems before they scaled.
AI removes that brake. It will cheerfully duplicate code thousands of times, reinvent solutions that exist elsewhere in the codebase, couple components without understanding consequences. It does exactly what the structure and examples show it—whether that's what you meant or not.
The teams succeeding aren't rejecting AI or embracing it blindly. They recognise it as an amplifier of whatever architectural decisions already exist in their systems. They invest in unglamorous work: refactoring, establishing clear patterns, building systems both humans and machines can understand.
The future may need fewer people writing functions. But it desperately needs people who think about systems, maintain architectural discipline, and understand that programming was never about typing. It was always about making decisions under uncertainty, evaluating trade-offs, designing solutions that work today and adapt tomorrow.
AI hasn't changed that truth. It's made ignoring it impossible.
The developers thriving in 2025 aren't the fastest typists or the cleverest prompt engineers. They're the ones who understand that every line of generated code exists within a system, that systems require thought and structure, and that machines are powerful servants but terrible masters.
The pendulum isn't swinging backwards. The industry is simply learning that moving fast and breaking things was only ever viable at small scale. AI gave us the ability to break things at unprecedented speed. What we're discovering, painfully, is that fixing them still requires human judgment, architectural discipline, and the wisdom to know that not every problem should be solved by generating more code.