Vibe coding, sometimes called prompt-driven development, describes a workflow where developers rely heavily on AI tools to generate code, often without deep involvement in architecture, low-level design, or even full comprehension of the output. Instead of writing code line by line, engineers shape prompts, review AI output, and adjust until the result fits with what they need.
This practice has spread rapidly. As AI models grow more capable, teams feel empowered to move faster than ever. Yet, as more organizations experiment with replacing junior developers, or entire roles, with AI tooling, one question becomes unavoidable: Does vibe coding actually scale?
Note that this is a rapidly developing field, with new capabilities and new models appearing all the time. Bear this in mind while reading, but the core principles discussed here will be valid and relevant for some time into the future.
A friend recently told me their company chose not to hire a cohort of junior developers. Instead, leadership issued Augment licenses to the entire team, instructed them to generate all code through prompting, and raised productivity expectations accordingly. Overnight, the team’s workflow changed, less building, more directing; with the goal to shift focus away from the mundane details of software development to designing the broader architecture.
But what happens when you try this on a larger scale? Can you still read and understand the code? Is the code maintainable? My immediate concerns would be the readability and maintainability of the code after a long period of time. I have experimented with the Agent features in Co Pilot and similar tools and there have been multiple times where the agent will attempt to make changes across many files and then suggest something that is actually wrong and doesn't fit my use case.
However, if an entire team is generating all of their code, can they keep up with reviewing it and catching these fundamental architectural errors? Despite this one could argue that, if you are only using AI for prompting, the code doesn’t need to be understandable or maintainable by people as long as the AI understands it. However, I do not believe AI is even close to being reliable enough to rely on for the complete development of large code bases in the long term.
Several large scale companies such as Google, Microsoft and Meta are experimenting with migrating to a more vibe-driven development style. These companies are able to do this through providing their employees with custom LLM’s. These often run on the companies local infrastructure and are trained on the companies policies, projects and working styles. A good example of this is Uber’s ‘Genie’ which has access to all of their slack channels and support tickets. Google and Microsoft claim that approximately 30% of their production code is AI generated and this percentage will most likely continue to grow.
However, these may not be representative of how the majority of mid to small sized companies will use AI for generating code. They will not have the resources to support large scale custom LLMs trained on internal resources and must instead rely on the AI tools and services available through subscriptions and licenses.
Some creative agencies have flourished with vibe coding. Because their work revolved around short-term deliverables, landing pages, prototypes, marketing tools: the long-term risks were minimal. Here, vibe coding increased agility without lowering maintainability, simply because maintainability was never the goal. A prime example of this is the Swedish startup Lovable who uses a fully agentic engine for interpreting requests and modifying codebases. They were valued at $1.8 billion even before producing a finished product, which is an astounding feat.
As output scales, so does the potential for code sprawl. Even with consistent prompting patterns, AI can introduce subtle differences in style, structure, and naming conventions. Over time, these micro-variations accumulate, leading to a messy, inconsistent codebase.
This will eventually result in a shift from “generate > ship > iterate”, to “generate > decipher > debug > refactor” as the code volume grows. In smaller teams, this can be manageable. Prompt discipline, code reviews, and architecture guidelines help maintain coherence. But in large teams, especially those generating thousands of lines of code daily, controlling drift becomes exponentially harder. Some AI tools like Augment provide features for giving the AI strict rules and guidelines with regard to coding style, conventions and documentation in order to keep the codebase consistent and readable. However, it is difficult to cover all potential avenues for mistakes and even hallucinations which AI can make.
The core tension lies here:
- Vibe coding increases throughput dramatically.
- Maintainability becomes harder to guarantee.
Although AI can produce functional code quickly, understanding and maintaining the code will, at least partially, remain the developers responsibility when things go wrong. If developers lack the context of how or why components exist, long-term stability will suffer.
Even with perfect documentation prompts, the nuance of why something was built a certain way often vanishes. This becomes a serious issue in critical systems, where reasoning matters as much as results.
As shown in my friend's organisation, some executives believe that the cost savings alone justify the shift. If three experienced developers plus AI can produce as much code as a ten-person traditional team, why not reduce payroll?
From a financial perspective, the argument is compelling, however, the hidden costs complicate the picture:
- More time spent debugging code no one actually wrote
- Higher onboarding friction for new engineers
- Increased reliance on tribal knowledge (which is thinner in small teams)
- Greater risk when senior engineers leave
- More brittle systems with AI-generated patterns embedded deeply
Meanwhile, large traditional teams may move slower, but they cultivate engineers who understand the architecture intimately , especially juniors who grow into mid-level maintainers. The question becomes: Does faster output now justify higher maintenance burdens later? And the answer depends on the organisation’s risk tolerance and time horizon.
Ultimately, vibe coding poses a dilemma. It offers extraordinary acceleration but introduces uncertainty when scaled. Some companies will thrive using it; others may find themselves trapped with heaps of spaghetti code which no one directly owns. I believe the success of vibe coding in an organisation will depend on the dev team’s discipline for creating and managing AI-driven output consistently, and with strict reviews of the architecture and design.
Discover More
We're software development specialists boosting our client's business with bespoke systems. We're practical, pragmatic and commercially minded, which means we do the right thing for you when it comes to building software.
New
