The Promise of Hyper-Productivity
Tools like GitHub Copilot and other generative AI assistants have fundamentally changed the mechanics of software development. The pitch was irresistible. By automating repetitive and boilerplate tasks—generating code snippets, writing unit tests, and even
drafting documentation—AI would free up developers' mental energy for more creative and complex problem-solving. Early studies seemed to confirm this, with some reports showing significant time savings on daily tasks. Many developers did feel more productive, reporting higher job satisfaction and less burnout as they offloaded tedious work to their new AI partners. The expectation across the industry was clear: this efficiency boost would naturally lead to shorter workdays and a better work-life balance.
The AI Productivity Paradox
Despite developers feeling more productive, a strange thing happened: overall project delivery times didn't necessarily shrink, and working hours remained stubbornly high. This phenomenon is being called the 'AI productivity paradox'. While AI accelerates the writing of code, it doesn't speed up the entire software development lifecycle. In fact, it can create new bottlenecks downstream. The sheer volume of AI-generated code often overwhelms the crucial stages of review, testing, and deployment. One developer's 10x output can quickly become another's 10x review burden, leading to a situation where teams are generating more code than ever but not necessarily delivering value any faster. It’s a classic case of local optimisation, where making one part of a system faster just shifts the bottleneck elsewhere.
More Code, More Complexity
The increased output from AI tools also introduces another challenge: complexity. AI can generate vast amounts of code quickly, but this code isn't always perfect. It requires careful validation, debugging, and integration into existing systems. Developers report spending significant time prompting the AI, evaluating its suggestions, and cleaning up incomplete or low-quality outputs. In some studies, developers ended up rejecting more than half of the AI's suggestions, adding friction and context-switching that ate into the initial time savings. Ironically, some research found that while developers felt about 20% faster when using AI, they were actually 19% slower at completing tasks due to the overhead of managing the AI's output. This suggests that the cognitive load isn't being reduced, but rather shifted from writing code to reviewing and verifying it.
The Rise of the 'Supervisory Engineer'
This shift is fundamentally changing the role of the software engineer. The job is becoming less about the manual craft of writing lines of code and more about directing, evaluating, and correcting AI output. This emerging role is sometimes described as 'supervisory engineering'. The most valuable skills are no longer just about programming language fluency, but about strategic thinking, system architecture, prompt engineering, and critical evaluation of AI-generated work. As AI handles more of the routine coding, senior developers, in particular, find themselves spending more time on code reviews and governance to ensure quality and maintainability, a shift that increases their workload. This evolution is also creating a challenge for junior developers, who may get fewer opportunities to learn foundational skills if AI automates the very tasks they would have started with.
Expectation Creep and the 'Denser' Workday
Finally, there is the simple human and organisational element of 'expectation creep'. As tools become more powerful, management's expectations for speed and output naturally increase. The time saved by AI isn't banked as free time; it's immediately reinvested into tackling more features, more complex problems, and tighter deadlines. The workday hasn't necessarily gotten longer, but it has become 'denser'—packed with more activity and a higher intensity of work. This aligns with the classic principle of Parkinson's Law: work expands to fill the time available for its completion. The new efficiency gains from AI are being absorbed by an ever-increasing scope of work, leaving developers feeling like they are running faster just to stay in the same place.
