AI can generate code, but not craftsmanship

“A computer can never be held accountable, therefore a computer must never make a management decision.”

Back in 1979, IBM included this pithy sentence in its training manual. What was written in an age where personal computers were yet to become a fixture in every house, and the internet as we know it today didn't exist, is still relevant in this age of smartphones, ubiquitous high-speed internet, and generative AI.

Today, large language models (LLMs) that power generative AI can write twice as much code as a human in seconds or minutes—a fraction of the time that a developer would take to write code manually.

And because these LLMs are trained to generate responses based on prompts in natural language, it's possible for a developer to "tell" AI what they're expecting the code to do (or the "vibe" they're going after), and lo and behold, the code is generated before their coffee break is over.

Andrej Karpathy, a founding member of OpenAI, called this approach "vibe coding," which gained traction among software engineers and developers worldwide.

Adding to the hype, the CEOs of Google and Klarna, Sundar Pichai and Sebastian Siemiatkowski, respectively, revealed that they have been personally vibe coding and attested to its productivity gains. Vibe coding had gained legitimacy—or so it seemed.

Vibe coding to vibe debugging

As self-proclaimed vibe coders on social media declared the merits of AI-powered programming and waxed eloquent about how it "democratizes" software development by empowering non-coders to build software using natural language, the cracks began to show.

First, the AI-generated code was riddled with errors in many cases, which can go undetected by non-technical users who lacked programming expertise. And software projects and websites built with such erroneous code ended up being buggy and unreliable.

Such troublesome code led to another serious problem: security concerns. Vibe-coded websites and applications were found to be highly vulnerable to hackers, risking exposure of sensitive user data. Things got so bad that programmers began offering vibe code fixing services to fix AI-generated code. The software world moved from vibe coding to vibe debugging real quick.

Why did the promise of vibe coding ring hollow? As one software engineer put it, LLMs suffer from three issues that render them incapable of building error-free software:

• Context omission: LLMs directly answer prompts without seeking out missing context. Without the necessary context, the responses are generated based on the model's assumptions, leading to errors.

• Recency bias: They prioritize the most recent piece of information over past information, tending to generate outputs without historical context.

• Hallucination: Models can generate fictitious, illogical or plain nonsensical code despite the quality of prompts.

So, as the summer of optimism made way to the winter of disillusionment in the Vibe Coding Wonderland, IBM's 1979 warning became clearer than ever to businesses: In the process of building quality software, only humans must make decisions, as no amount of technological leaps can make computers accountable.

Simon Willison, an AI researcher and software developer, said: "I firmly believe that as a developer you have to take accountability for the code you produce—if you're going to put your name to it you need to be confident that you understand how and why it works—ideally to the point that you can explain it to somebody else."

Writing the code is usually the easy part. The hardest and most essential part is knowing what to write—one that distinguishes vibe coding from software craftsmanship.

Crafting software with good vibes

The book Software Craftsmanship: The New Imperative by Pete McBreen, published at the turn of the millennium, still holds valuable wisdom for developers in the age of AI-powered coding.

Defining craftsmanship as "a subtle blending of man, machine, and knowledge to create useful artifacts," he explains that developers who adopt the craftsmanship mindset put "responsibility and pride" into the software development process and hold themselves accountable for the software. This establishes trust between developers (the vendor organization) and users, and also results in better software.

"Software craftsmanship gives customers what they need—namely, stable, long-lived applications rather than old-style legacy applications that cause significant disruption and trauma every few years when they have to be replaced. Software craftsmanship provides a real alternative to the world of disposable software," McBreen wrote.

Embracing software craftsmanship will help businesses stay competitive by delivering robust and delightful software that have fewer defects, faster incident recovery, and minimal security incidents, which will eventually compound into lower costs and stronger customer trust.

At Zoho, this ethos has guided us since our inception. We approach building software that delivers high value as a craftsman would: whittling down the unnecessary parts and refining the necessary parts.

We've been in business for three decades now, during which we've crafted over 55 software products that fit almost every business need. Our 130+ million users around the world are a testament to our commitment to craftsmanship.

Also read: The art of software

Software craftsmanship doesn't preclude the use of vibe coding. Given the limitations of AI-generated code, engineering teams may limit its use to low-risk settings like prototyping. AI can help developers experiment and iterate faster, but given the lowered barrier to entry, it's important now more than ever for teams to set the bar for software quality as high as possible, which is where adopting software craftsmanship helps.

As McBreen put it in his book: "Ultimately, it is about humans regaining control over their environment, rather than machines dictating what is possible."