Beyond vibe coding

Modern AI-powered coding assistants are completely changing the rules of the game in the business world and in software development, too. Since the boombastic arrival of ChatGPT and Copilot, new products and approaches, like Vibe Coding or Agentic software development, have been proposed at an astonishing pace, each promising revolutions and paradigm shifts.

The change isn’t merely technical. It can be an entire transformation of the whole sociotechnical system around software. Democratising or commoditising software development, shaping teams and interactions in novel ways, to potentially create new businesses and destroy old ones.

In this chaotic, accelerated environment, “AI” means too many things; are we talking about more intelligent code completion, or generating entire software applications with a good collection of prompts? In the software world, different approaches are appearing, attacking different portions of the problem space and offering interesting opportunities. Meanwhile, different players are telling different stories. While evangelists and explorers may lean too much toward marketing, professional engineers often lean too much toward skepticism. As always, context is king. And while the promise of AGI is yet to come, the new tools offer professional software engineers a new set of game-changing tools to learn and master.

Vibe Coding

Vibe Coding is the most famous approach. The term was originally coined by Andrej Karpathy and describes one of the most ambitious approaches to AI-assisted development, in which AI handles most implementation details and follows conversational instructions. In Vibe Coding, we treat the code as a black box. Some tools are already tuned to a given implementation stack, taking care of countless implementation choices.

A Liberating business case

Vibe coding is the approach that had the most devastating impact on the job market. Being able to describe the expected behaviour of a software application to a chatbot and seeing it appear magically was nothing short of miraculous.

In the eighties, two friends of mine were unpacking a brand-new Commodore Vic-20, lured by the promise of “You will build your own video games.” They switched it on and decided to start with something easy: Arkanoid. The screen was empty, so they typed: “Make a wall.”

Tools like Lovable and Windsurf offer the illusion of simplicity in a world where software developers keep repeating the mantra “It’s not that simple.” This makes vibe coding an incredibly tempting opportunity for business stakeholders who can’t code.

The apparent simplicity is true only if we ignore the underlying complexity. Most software costs are associated with maintenance, not to mention the engineering complexity to guarantee reliability, robustness, and security. Still, vibe coding delivers working software that can be a good fit for many business cases, not worthy of traditional professional software development.

Pitfalls

The magic of vibe coding has a few dark sides to consider.

Language precision

AI performs better when you can provide precise, unambiguous prompts. This is not an easy sport for many end users and requires a modelling discipline that is not different from that of a software developer. You can’t leapfrog from vagueness to working software. You still need clarity and well-formed thoughts. There is no shortcut for understanding.

Stability

Every added feature increases the codebase’s complexity. A black-box user won’t get the signal at the code level, but every new variation increases the hidden technical debt. No one is in charge of internal design integrity. You start noticing something is wrong when adding a new feature breaks the previous one. This is when you should definitely open the black box and open the internals, but maybe it’s already too late.

Without explicit attention to design integrity, fixing one issue opens another one, and the awe of the first prompt can turn into frustration.

Maintenance

Maintenance is clearly the dark side of Vibe Coding, not only because the code quality produced is inferior to what a good developer could write, but also because it would be tough to hire talented software engineers to maintain a Vibe-coded codebase. “I’ll envision things, you’ll repair them” is not a compelling call for a healthy collaboration.

Accountability

Who owns the vibe-coded source? Who is accountable for it? The answer is probably nobody, which makes the current state of vibe-coded software artifacts unsuitable for critical environments. Would you run your e-commerce on a Vibe-coded app? Would you be legally responsible for potential fraud coming from the software you can’t read?

The perfect business cases

Vibe Coding is actually an excellent fit for small projects, with a low risk profile:

• Rapid prototypes to gather feedback.
• Proof of concepts in new stacks.
• Personal projects where you own the risk and the consequences.
• Short-lived application with low security requirements.

The market can potentially be huge, but it may not be the market you’re in.

AI-Assisted Software Development

AI-Assisted Software Development builds on a different narrative. The black-box approach from Vibe Coding isn’t working for professional software developers. They know software is a liability, and Vibe Coding is a liability generator. Knowing the software internals and pretending to ignore them – while being still accountable for the software behaviour – isn’t a viable strategy. So, professional software developers are leveraging a different approach.

Definitions are still fuzzy and still in the making, but AI-Assisted software engineering refers to a white-box style of software engineering that leverages the potential of modern AI tools like Claude Code. The human programmer is in charge, but provides instructions and background to the coding assistant to ensure the result meets the expected standards.

Mixing speed and discipline

In this scenario, coding assistants can be mighty companions. But the developer should be in control, like riding a horse. Coding assistants do not smell fear, but they can drag you off track very quickly, solving puzzles they created, adding unnecessary complexity, and so on. Your coding assistant can be incredibly useful in some tasks – integrating with external platforms has become significantly easier – but it can also hallucinate, or complicate your codebase with weird assumptions.

When dealing with unchecked power, the emerging need is to build an environment where the developer is in control and resists the temptation to vibe-code. Good old practices like Test-Driven Development or Behaviour-Driven Development can provide a more solid foundation for a faster yet sustainable pace of building robust applications.

In Process Over Magic: Beyond Vibe Coding, our friend Uberto Barbini describes an approach to AI-assisted software development that blends discipline with power, while keeping control.

Canned Wisdom

Providing a solid background to your coding assistant doesn’t come for free. There’s a lot of trial and error: you provide better instructions after realising how the previous ones have been misinterpreted. To an expert software developer, this process feels a lot like mentoring a junior, with an annoying attitude – always pretending to know the answer – and a goldfish-grade memory.

The hard limits of the context window – the amount of conversation that the coding assistant will remember – will nudge you into providing repeatable guidance in the form of human and machine-readable markdown files. But here is a twist. You can capture your personal coding style in these markdown files, or define a common set of standards with your team.

They can also become cross-project reusable assets, like adding picky-senior-code-reviewer to our human+AI development team. They can be shared, sold, downloaded, and combined. We are just at the beginning of the story.

Pitfalls

It’s hard to detect the signal from the noise in a wide conversation. The vendors’ marketing propaganda promises miracles. Grumpy developers tell horror stories about hallucination. Research numbers also show an interesting gap between perceived individual productivity and systemic impact. Maybe coding was not the real bottleneck.

When talking with professionals who went beyond the surface, some common traits stand out as critical challenges for the new shape of the profession.

Easy to lose control

The need for discipline is pervasive. It’s like being on a diet and working in a candy shop at the same time. Established practices like the red-green-refactor cycle are getting challenged by the different speed and cadence of the coding assistant, and by our perfectionism, too. The interaction with the coding assistant occurs at a speed that invites multitasking and frequent context switching, often leading to lower-quality reasoning.

Different levels of trust

AI tools produce “average code”, by definition.

Good developers will find AI-generated code embarrassing in the areas they master; this is where they’ll teach AI to improve and become a decent apprentice. But no developer has evenly distributed mastery over the whole stack. In some other corner of the code base, average code is bliss. A working solution that doesn’t require studying the documentation for a new technology can save the day. But here is where we may not be competent enough to catch antipatterns or vulnerabilities.

Too many hats

Many success stories – including ours – with AI-assisted development are solo projects. This is not a surprise: pet projects are the perfect playground for learning. But limited risk and impact aren’t the only distinctive traits of a pet project; a subtler difference lies in our role. In a typical pet project, a single person plays the role of:

• chief engineer taking orders from nobody
• key stakeholder the software serves our needs
• domain expert, most of the time.

In other words, we have relatively straightforward requirements in our heads, without needing to talk to anyone else. We can write specifications thinking like software engineers. But in a typical software project, the senior software developer might not own the precise formula for the business need. Meaning that there are new interactions to uncover in the collaboration between the business stakeholder and the software team

Not for Juniors

There are concerning signals that AI-assisted coding is disrupting the learning paths of young software developers. The pervasive availability of shortcuts to the solution and the impatience of business stakeholders create a fertile ground for skipping the hard part. Junior developers can build a solution that is only apparently comparable to what seniors could deliver. But they may be helpless when it comes to maintenance and problem determination, ultimately adding very little value compared to the Vibe Coding alternative.

Meanwhile, mentoring has become a scarce resource. Many senior developers are prioritizing their own upskilling and training coding assistants rather than investing in juniors’ growth. And in many workplaces, remote work is reducing the available bandwidth for knowledge transfer.

Agentic Coding

The perspective of Agentic Coding is different, likely closer to that of a software team leader or a Dungeons & Dragons party leader. You’ll take the delegation to the next level while still overseeing the orchestration of the different contributors. Instead of teaching AI to be the perfect super-companion, we may accept some technological limitations and opt for a more focused, specialistic approach. A specialised agent will be equipped to perform a specific task, such as reviewing your codebase for security vulnerabilities or UI-level inconsistencies.

Assembling your party of specialised agents and defining a collaboration workflow can enable you to delegate more complex tasks. With sufficient confidence, you can establish a different workflow: long-running tasks can be planned during the day and run overnight without supervision. The morning can be reserved for the necessary fine-tuning and designing a new plan.

A new type of temptation

Craft, passion, and systematic improvement in configuration and guardrails can significantly improve the quality of the code delivered by our AI party of agents, but … can we ever get to perfection? Or is our aspiration for the perfect prompt, the perfect markdown configuration, and the ideal agent workflow just a massive distraction game with decreasing ROI? Are we solving a problem, or are we engineering the meta-solution for the meta-problem?

Not for everyone

You can trust an agent as long as you can still verify the output. This means software engineering skills are still badly needed. Senior full-stack developers with a wide range of competencies can build their specialised team of agents while still retaining control over the orchestration. Specialised software developers will still have selective blindness. Cross-competencies aren’t a commodity, but this is an excellent opportunity for those who can master the whole stack.

Shifting the bottleneck

In many settings, writing working code stops being the bottleneck. Prototyping is getting cheaper, enabling faster feedback loops. But we still need human input to determine whether we are moving in the right direction. Expert availability might become an issue, or we might realise that we need time to digest the information.

More radical approaches

As it already happened in the ‘00s – does anyone remember MDA? – the new tools are fueling the imagination for new development workflows where the source code is not the primary artefact anymore. The main challenge here is that for most business software, requirements are not precisely specified, and they’ll never be. It still takes loops to understand what the real requirements were. Some software can be deterministic – like an adapter between APIs – but add legacy, malformed data to the mix, and you will find yourself begging for expert business advice.

Spec-Driven Development

Spec-Driven Development, pioneered by tools like Kiro, constrains the prompt to a more structured approach, iterating on the specification level before generating code. The approach sounds a little more waterfallish, but it can be an excellent fit for regulated environments, where specifications are first-class citizens.

The Ralph Wiggum

Despite the funny name, this is a fascinating approach based on the idea of relentlessly looping until a satisfying outcome is reached. A combination of agents would stay in the loop, refining or rebuilding the output of the previous agent until all completion criteria are met. This implies considerable upfront effort to specify the desired outcome better, but it can handle longer tasks with limited human supervision. For example, migrating a database from an old legacy version to a new one could be specified as a set of high-level requirements, like:

• All records need to be moved to the new platform.
• Exceptions during migration will require an investigation and special handling.
• No information should be lost or discarded.
• Task is over when the complete migration happens with no reported exceptions.

However, this approach won’t work well with fuzzier feedback, such as in exploratory or UI-intensive domains, where human feedback is the bottleneck.

The Phoenix Architecture

The Phoenix architecture, advocated by Chad Fowler, builds on the idea of regenerating the codebase whenever a new constraint is added.

Conclusions

We are living a paradigm shift happening at an incredible speed. Ideas, products, and options are popping out at an accelerated pace. Is it all good? Not really, but the potential is enormous and worth exploring. However, the scenario is vast and nuanced.

Just because an approach worked for someone doesn’t mean it will work for you. And just because you tried something and it didn’t work, doesn’t mean it’s flawed.

There are plenty of use cases in software development, and our toolbox just received a massive upgrade. There won’t be one winning approach. We’ll probably have to develop different workflows for different scenarios.

---

We are offering new training formats for software professionals who are willing to experiment with AI-powered approaches.

• AI Assistants for your team with Uberto Barbini offers a way to harness the power of AI tools while preserving control and code quality.
• AI + Continuous Modernisation with Matteo Vaccari focuses on using AI to build control over legacy codebases.
• The agentic developer with Marco Heimeshoff will give you a powerful toolkit to master agentic software development.