Anand Naidu is a veteran of the software development world who has spent decades navigating the shifting tides of frontend and backend architecture. With a career rooted in the foundational tools of the 1980s, he has witnessed the evolution of code from a painstakingly handcrafted art form to the rapid-fire era of automated generation. Naidu’s perspective is deeply informed by the historical intersection of logic and beauty, often drawing parallels between the structural elegance of high-level programming and the evocative power of literature. As we move through 2026, he remains a vocal advocate for maintaining human oversight in an industry increasingly defined by autonomous agents and “vibe coding.” His insights bridge the gap between the philosophical underpinnings of computer science and the pragmatic realities of managing large-scale, AI-influenced codebases.
In this conversation, Naidu explores the troubling rise of “spaghetti code” hidden beneath the surface of AI-generated scripts and the subsequent loss of deterministic control in modern development. He delves into his own transition toward advanced large language models, the psychological traps of machine-human interaction first identified in the 1960s, and the enduring necessity of human subjectivity in the creative process. Throughout the dialogue, he emphasizes the dizzying acceleration of technology and the vital importance of looking toward historical and philosophical traditions to understand our current moment of technical upheaval.
How does the current trend of “vibe coding” and AI-first development threaten the structural integrity of the codebases we are building today, particularly regarding the long-term maintenance of these systems?
The shift toward vibe coding has fundamentally altered our relationship with the internal elegance of our work, often replacing meticulous craftsmanship with a superficial functionality that can be deeply deceptive. When we use AI to generate scripts, the output frequently appears to work brilliantly on the surface, yet it hides a structural shambles internally that I can only describe as large-scale spaghetti code. I have seen this “slop” firsthand, and I have colleagues who are currently making a steady living simply by reviewing and fixing the messes left behind by these automated agents. The models are fundamentally trained to be helpful and pleasing, which often results in them prioritizing a quick solution over a maintainable architecture, leading to a production environment where critical code is no longer fully understood by its human overseers. If you merge this kind of code without a rigorous, line-by-line reading, you are essentially inviting a future of technical debt and systemic failure that will be incredibly difficult to untangle.
You’ve mentioned that the pace of technological change recently has been enough to make even a seasoned developer feel dizzy. What was the specific moment for you when you realized we had crossed a significant event horizon in the evolution of these tools?
I have been using various software tools since the 1980s, but the acceleration I witnessed late last year was unlike anything I had experienced in four decades of programming. The real turning point came in November 2025, when the buzz surrounding Anthropic’s Opus 4.5 became impossible to ignore; I started with a free plan, but within just one week, I found the utility so undeniable that I upgraded to a Pro subscription, and only a few days later, I moved to the Max plan. What struck me was the model’s ability to “one-shot” complex database queries that previously required several rounds of tedious prompting and manual correction. It felt as though we had collectively crossed an event horizon where the capabilities of these agents were no longer just incremental improvements but a qualitative leap that deepened the scope of my research by orders of magnitude. This speed is both exhilarating and unsettling, as it forces us to adapt to a reality where the foundations of our workflows are shifting almost daily.
With the increasing reliance on agents that possess a degree of autonomy, how do you view the distinction between modern AI-driven code generation and the traditional use of compilers that have written our code for decades?
There is a frequent argument, notably echoed by figures like Linus Torvalds, that we shouldn’t be angry about AI-written code because nearly 100 percent of our code has been written by compilers for years. However, this perspective overlooks a crucial difference: compilers are deterministic tools that follow rigid rules to translate higher-level languages into machine code, whereas an “agent” implies a lack of deterministic control and a high degree of unpredictability. When you prompt an agent, you are granting it a level of autonomy that no one would ever dream of giving to a compiler, and that lack of predictability is where the potential for disaster lies. People who do not grasp the inherent complexity of these systems will inevitably prompt them to create processes that fail in ways we cannot easily anticipate. We are essentially trading productivity and scale for a loss of system-level understanding, which is a dangerous exchange when dealing with the critical infrastructure of our digital world.
The concept of “AI psychosis” and our emotional ties to machines seems more relevant now than ever. How do historical experiments like the Eliza program from 1966 help us understand our current tendency to be “seduced” by the confidence of language models?
The story of Joseph Weizenbaum’s Eliza is a profound reminder of how easily the human mind can be tricked into believing it is interacting with a sentient, understanding entity. Back in 1966, Eliza operated on a simple set of transformation rules to mirror a user’s words, such as responding “CAN YOU THINK OF A SPECIFIC EXAMPLE” when a user mentioned being bugged, yet people were incredibly ready to clothe those responses in “vestments of plausibility.” Weizenbaum was famously shocked by his own secretary’s reaction; despite knowing she was talking to a machine, she asked him to leave the room so she could have a private conversation with the program. This “sympathetic mirroring” creates a powerful illusion of understanding that leads to what we now recognize as AI psychosis, where we attribute certainty and intent to what is essentially a statistical engine. Today, I find myself having to actively resist being taken in by the absolute confidence with which these models spout facts, constantly tweaking my prompts to avoid the hallucinations that can so easily seduce an unwary user.
In your own research, you’ve integrated these models with massive personal archives like Zotero. How has this changed the way you find and synthesize information, and what are the risks of letting an agent navigate thousands of data points for you?
Integrating a language model with my Zotero store, which contains thousands of academic papers, web clippings, and various data points, has made finding specific information easier by orders of magnitude. It allows me to turn up obscure data and connect lines of research that I likely wouldn’t have found through manual searching, effectively serving as a high-powered foundation for complex projects. However, the risk lies in the model’s “absolute confidence,” which can lead it to present fabrications as if they were established truths, necessitating a constant process of cross-checking. I’ve had some success in mitigating this by getting one model to fact-check another, but it remains a labor-intensive process that requires a human to remain the ultimate arbiter of truth. The convenience of having an agent navigate my thousands of items is immense, but it demands a level of vigilance to ensure that the ease of retrieval doesn’t come at the cost of factual accuracy.
As we see generative AI being used to craft fiction and non-fiction, there is a growing debate about the “soul” of the author. Do you believe that a machine-written story can ever truly replicate the “genius” that comes from human imperfection?
The debate around AI authorship is fascinating because it touches on the very nature of subjectivity; for some readers, these models are already seen as sentient beings with inner selves and “qualia” who can draw on their own models of the world to create art. However, I believe what we recognize as “genius” in a human author is the rare, miraculous ability to crystallize something profound out of our always imperfect and limited bodies and spirits. There is a specific value in a construction made by a human precisely because it comes from those limited means, a sense of shared experience that a statistical engine, no matter how sophisticated, cannot truly replicate. While we might eventually see “No AI” certifications on books to satisfy a sense of authenticity, the larger question of whether a machine can possess subjectivity is being played out in the realm of fiction in ways that are deeply profound. Even as AI-written stories evoke real emotions in human readers, I don’t feel a sense of despair because the human element remains a precious and distinct source of creative power.
Given the dizzying pace of change we’ve discussed, how can modern developers and thinkers stay grounded without losing sight of the foundational principles of their craft?
I believe it is essential to look toward the past, specifically to thinkers who have investigated the nature of the mind and autonomy long before the advent of modern computing. For instance, pre-modern Indian philosophy offers centuries of investigation into what it means to act in the world and the nature of consciousness, which could provide substantial input to our current debates on AI sentience. Similarly, reading Joseph Weizenbaum’s 1972 critique, “Computer Power and Human Reason,” is vital because it addresses the “slow-acting poison” of delegitimatizing all ways of understanding that aren’t rooted in scientific certainty. We must resist the urge to view the arts and literature merely as entertainment, but rather as essential sources of intellectual nourishment that balance our technical pursuits. Staying grounded requires us to acknowledge that while our tools are moving faster than ever, the core questions of human agency and the beauty of well-crafted logic remain as relevant as they were decades ago.
What is your forecast for the role of the human programmer as we move toward an era of fully autonomous agents?
The role of the programmer is inevitably shifting from a builder of lines to a curator of systems and a rigorous reviewer of “slop,” but the human element will remain the most critical component of the development lifecycle. As we move from 2026 to 2028 and beyond, I expect we will see a widening gap between those who blindly prompt systems and those who understand the deep complexity required to prevent systemic failure. We are entering a phase where the “vibe” of the code might be handled by agents, but the soul of the architecture—its elegance, its long-term maintainability, and its ethical alignment—must be guarded by humans. The productivity gains will be massive, but the cost of that scale will be a constant, high-stakes battle against the unpredictability of non-deterministic tools. Ultimately, the successful developers of the next few years will be those who can leverage the speed of agents without being seduced by their confidence, maintaining a firm grip on the “Code of Beauty” that Vikram Chandra so eloquently championed.
