Software teams hit 90% AI-generated code but face validation crisis and cognitive burnout

When Writing Code Is No Longer the Issue, What Is?

AI has fundamentally changed software development, and this is how it happened: gradually, then suddenly. Over the past few years, engineers have been experimenting with AI code, but the latest progress has enabled us to do things we never thought possible before. The recent model upgrades, combined with agentic abilities, now allow developers to produce not just dramatically more code, but dramatically more complex code. In the span of a quarter, my own team went from skeptical experimentation to 90 percent of our code being AI-written. But this isn't a productivity triumph story. Because when code production becomes fully automated, you get a new set of problems to think about. Here are some challenges the development community is dealing with right now. Accept that the job has changed This shift first requires a mindset change. Engineers need to accept that what they built their careers around has transformed at its core. The developers adapting fastest today were never particularly attached to coding itself. They've always been more interested in systems, architecture, and development practices. For them, AI removed the tedious part. But some are more focused on the craft of writing code. They've honed their skills, specialized in a language, and even developed a personal style. When AI absorbs that layer, it's disorienting in a way that goes beyond skill obsolescence. It's disruptive to their entire professional identity. Team leaders will need to manage both types and those in between. So alongside technical challenges, we're all dealing with change management issues. If we don't name them, discuss them, and actively work through them, no one moves forward. Velocity without governance = slop When you can produce in half a day what used to take five, it's easy to get carried away by the magic of it. But AI-generated code can be deceiving. It looks correct on first read, but it isn't always right, and it's often undertested. Without a proper system in place, teams start to accumulate slop -- technically functional code that's bound to surface problems in production, often in ways that are hard to trace back. That's why our prime focus right now is building a validation system. When slowing down isn't an option, you need a structure that lets you move quickly, without the code degrading beneath you. The acceleration outpaced our infrastructure, and now we're building the net while we're falling. Review is the new bottleneck Solve the slop problem, and you immediately surface the next one: human review. In a single week, I personally reviewed 68 pull requests -- proposals for code changes that need senior team member approval before merging the code. Because of the sheer volume of new code, reviewers are now receiving two or three times more requests than before AI was used for coding. The reviewers also need to perform their reviews with less context, because they weren't in the room when the code was generated. While this code can look fine on a quick pass, it requires engagement to evaluate properly. The fix is building more automated validation earlier in the pipeline to catch problems before they reach a human, so the human reviews are meaningful rather than overwhelming. The validation loop is the real skill now Here's the difference between teams getting genuinely good output from AI and teams getting mediocre outputs: the validation loop. You need to give the agent criteria for success and failure. Let it run the tests, read what broke, and iterate before it hands anything back to you. This is what Claude Code made concrete for us, by moving the experience into the terminal, where the agent can execute code, read CI/CD results, and course-correct on its own. That's how you close the loop. Teams treating AI as a prompt-and-receive tool are capturing maybe a third of the available value. The ones who've figured out how to let the agent self-validate are operating at a different level entirely. Nobody has a clean playbook for building these systems yet. AI drains you faster than you think AI-enhanced work compresses the decision density of your day. You're making high-level architectural calls constantly, at a pace that traditional coding doesn't demand. By mid-afternoon, you're cognitively depleted and it's hard to explain that to someone who hasn't experienced it, because on paper, you've been "productive." But your brain has been running hot in a way it's not designed to sustain itself for eight hours. Some have started calling this the "AI vampire effect." The tool gives you enormous capacity, but drains you in parallel. The partial fix, again, is the validation loop. With that in place, there's less cognitive load on the human and more delegated to the system. But it also requires honest management. The sustainable working pace in this new context is different than before. Pretending otherwise is a good way to burn out your best engineers. When does the next version of software development launch? The acceleration in the AI space happened faster than our systems, processes, and instincts could keep up with. It's now easier to produce code, but that's precisely why it's important that we rethink everything surrounding the production process. For now, no one has a clear model for how this should look. What exists are teams like ours, feeling their way through it, building validation systems in real time, managing engineers through an identity shift nobody trained us for, and occasionally reviewing 68 pull requests in a week while wondering if this is sustainable. It is, but only if we take the matter as seriously as the code itself. The engineering problems we can solve eventually. The harder question is whether we'll build the right habits, systems, and culture around AI fast enough to keep up with what AI keeps unlocking.

Thoughts on Developing With A(ccelerated) I(nference)

Join the DZone community and get the full member experience. Join For Free AI stands for artificial intelligence, yet I prefer the term Dr. Venkat Subramaniam used in one of his talks: Accelerated Inference. To my mind, it is far more accurate, so I have embraced it. And "accelerated" is precisely the point. With AI, generating code has become cheap; it is no longer the bottleneck of software development. What has become expensive, and what this article is really about, is everything around it: aligning outcomes with intent, owning what we ship, and exercising the judgment that no amount of acceleration can replace. A Brief History The main structures underlying modern AI are neural networks and transformers -- statistical models capable of replicating patterns. The former have been around for much longer than many people today assume; the latter are comparatively new. The field's milestones trace a recurring cycle of bold ideas, disillusionment, and breakthroughs driven by new algorithms, more data, and faster hardware: from the first mathematical model of an artificial neuron (1943) and the perceptron (1958), through the first "AI winter" (1969) and the backpropagation revival (1986), to AlexNet's deep learning breakthrough (2012) and the Transformer architecture (2017) that underpins all modern large language models. In other words, AI as a concept is not new at all. What is new is that today almost everyone, technical or not, has an opinion about AI and how it is changing the way we work. On one hand, this is perfectly normal: the world isn't what it used to be, the available tools are different and more powerful, and certain problems can now be solved much faster. On the other hand, in this new and fashionable landscape, people should strive to form objective opinions first, filter them through their own judgment, and only then express and apply what proves useful. From individual to individual, hasn't this always been the case with everything else? Habits Worth Keeping (and Acquiring) When it comes to people, the recommendations on how to act when 'newness' emerges haven't changed from what we've been used to. Certain responsibilities and habits should be kept, others adapted and continually improved, while new ones acquired. Regarding software engineers, I feel slightly more entitled to an opinion; thus, here are a few pieces of advice I have compiled and consider worth having close. * Before writing code, strive to turn incomplete and ambiguous requirements into a comprehensible starting point -- understand not just how to build something, but why and who it serves. * Before writing code, know when to use a certain algorithm or design, why it matters, and how it fits into the large application you are building. * Before merging in your code, have it reviewed first by yourself, then by at least one human programmer. * Get used to a shift in thinking. Engineers are used to predictable results; LLMs produce variable output. A switch from deterministic to probabilistic thinking may be needed. * Before merging AI-generated code, review every line in detail and thoroughly understand why each decision was made - transform the changes into fully owned ones, as if you had written them yourself. (sounds familiar, doesn't it?) * Before merging AI-generated code, make sure it meets the project's coding standards and remains human-readable, and improve it where possible. * Sharpen your code-reading and reviewing skills. They were always a plus; now that AI agents are programming buddies producing large volumes of output, they are essential. * Avoid "prompt-and-pray vibe coding." Use AI thoughtfully, maintain rigorous standards, and don't short-circuit your own learning. * Use AI as a force multiplier to amplify your existing skills -- knowledge, experience, problem-solving as a professional, and above all, objective, constructive judgment as a human being. * Validate both directions. Check not only what AI agents produce as output, but also what they consume as "trusted" input. * Co-build abstractions. Use LLMs to help build an abstraction, then use that abstraction to communicate with the LLM more effectively and solve problems in a more deterministic manner. * Keep delivering reliable, maintainable software, but pay closer attention to how you spend your time building it. Some of these points are about AI; some are not. Some have been acknowledged for ages; others emerged recently and will be assimilated sooner or later. From Writing Code to Solving Problems One thing is certain: with AI, the software development approach and mindset are fundamentally different. In this shift, I believe software engineers have a great opportunity -- to move their attention even further from writing code to solving problems, and to spend their energy on more meaningful challenges. Oleg Koverznev puts the thesis I opened with even more sharply: "... code generation is cheap and no longer a bottleneck; the real challenge is aligning outcomes with intent, along with managing the growing operational and economic complexity of agent-driven work." AI's instant output tends to fuel our impatient expectations for immediate results. It can make us feel productive and efficient, but let's hold on for a moment, resist the rush, and ask whether the outcome has real value, whether it actually produces impact. Going deeper, there is an idea I find helpful in sustaining this point of view. Luciano Floridi -- a leading figure in the philosophy of information and digital ethics, widely influential in AI ethics - has a thesis (sometimes referred to as Floridi's Conjecture) that can be summarized as follows: As the complexity of a system increases, the ethical significance of its interactions also increases, while the ability to fully predict or control its behavior decreases. In this view, advanced information technologies are re-ontologizing our world, reshaping the very fabric of reality and our place within it, rather than simply serving as tools within an unchanged reality. Applied to AI, the conjecture suggests that a fully autonomous system cannot have great scope and great certainty at the same time; AI agents will therefore always require human oversight. Yet more and more, out of convenience, people tend toward fully embracing agent autonomy, when it would be wiser to remain in the loop: tempered and watchful. Language, Thought, and Staying Sane Science in general and AI in this particular context is not a magic trick, but a special way of using human intelligence. We embrace science and AI not when we put on a white coat, but when we start practicing a set of canons of thought, many of which have to do with the use of natural language, which is, after all, the main medium of AI-human interaction. New technologies change what we understand by "knowledge" and "truth." They alter the deeply rooted habits of thought that give us a sense of the world, of the natural order of things, of what is reasonable, necessary, inevitable, or real. The actual magnitude of the effect varies from person to person. But as Neil Postman observed, a new technology doesn't merely add or subtract something -- it changes everything. It redefines the words by which we guide our lives: freedom, truth, intelligence, reality, wisdom, memory, history. And it never stops to warn us, and we never stop to ask. We keep rushing. Conclusion In these days when AI seems to be the solution for almost everything, I consider it very important to keep improving our reading, writing, and technical skills, our natural language, and our critical thinking, and to apply them wisely. To be respectful to ourselves and to others. To value truth more than mere correctness and, why not, to become good bullshit detectors as well. In a world where consumerism is amplified as never before, where objects are overvalued and abundant, and where speed is prized over competence and quality, remaining sane is a real virtue. Improving our human virtues is a continuous and tedious process, but a rewarding, fundamental, and safe one in the long run. Let's not change the world, let's change ourselves.