There's a quiet revolution happening in software development. It doesn't look like the revolutions we were promised: no general AI superintelligence, no robot coders replacing entire teams overnight. It looks like a product manager at a logistics company building their own internal dashboard in an afternoon. It looks like a nurse manager creating a shift scheduling tool that actually maps to how nurses work. It looks like a founder prototyping their SaaS idea over a weekend and validating it before spending a penny on engineering.
This is vibe coding: the practice of building software through natural language, AI-assisted iteration, and domain-led design, without needing traditional programming skills. And it's not a trend; it's a structural shift in who gets to create software.
What Vibe Coding Actually Is
The term was coined by OpenAI researcher Andrej Karpathy in early 2025, describing a mode of development where you describe what you want to a large language model and iteratively refine the result. You write English instead of Python. You describe the outcome you're looking for, not the implementation steps. The AI handles the syntax; you handle the intent.
The tools enabling this, including platforms like Cursor, Bolt.new, Lovable, Claude Code, and Replit, each take a slightly different approach. Some are browser-based IDEs, some are CLI tools, some focus on design-first workflows. What they share is a dramatic reduction in the technical overhead required to go from idea to working software. (We've compared all the major platforms here if you want a detailed breakdown.)
But the tools aren't the revolution. The revolution is what happens when they get into the hands of the right people.
The Domain Expert Advantage
Here's the dirty secret of traditional software development: the people who understand problems best are rarely the ones building the software to solve them.
A software specification travels through a chain of handoffs: business stakeholder → product manager → UX designer → developer → QA tester → and back around again. At every step, something is lost. Context erodes. The nuances that make a solution actually useful get filtered out.
A developer building a scheduling system for a hospital doesn't know that the overnight staff always work in pairs, or that certain wards require specific certification levels, or that pay rules change on bank holidays. The nurse manager who knows all of this intimately had that knowledge filtered out two handoffs ago (translated into a specification document that captures the surface but misses the texture).
"The best software is built by people who would use it themselves. For the first time, that's becoming universally possible."
Vibe coding short-circuits this chain. The person who owns the problem can now be the person who builds the solution. And the software that emerges is qualitatively different, shaped by real domain knowledge rather than a specification document's approximation of it.
The Speed of Iteration
Traditional software development is measured in sprints: two-week cycles of planning, building, reviewing, and testing. A change to how a single screen displays data might take a week to implement and another week to verify. The feedback loop between having an idea and seeing it in working software is long, expensive, and full of degradation.
Vibe-coded software iterates at the speed of thought. See something that doesn't quite work? Change it in thirty seconds. Want to try a completely different approach to the data model? Rebuild the feature in an hour. Testing becomes immediate and intuitive because the person building is also the person using; there's no handoff delay, no misinterpretation, no waiting for the next sprint cycle.
This speed compounds. An internal tool that previously required three months and significant development budget can now be created, tested, refined, and deployed in a week by someone who has never written a line of code. The time saved isn't just financial — it's competitive. Ideas that would have died waiting for development bandwidth can now be tested in the real world and validated or discarded before significant investment is made.
What's Already Possible
The range of applications being built this way is broader than most people realise:
- Internal tools: dashboards, reporting systems, inventory trackers, and customer management interfaces built specifically for how a business actually operates, not how a generic SaaS vendor imagines it might
- MVPs and prototypes: complete working prototypes with authentication, databases, and real interfaces, ready for user testing within days
- Automations: tools that connect APIs, process data, trigger notifications, and perform tasks that previously required custom backend development
- Client portals: bespoke interfaces for customers or partners, tailored to specific workflows rather than forced into generic templates
- Data tools: custom visualisations and analysis dashboards built against real business data, without the overhead of enterprise BI tooling
These aren't toy projects. With appropriate engineering attention applied, they can be genuine production software. Which brings us to an important caveat.
The Democratisation Argument
For decades, the ability to create software has been one of the most significant power asymmetries in business. Large organisations with engineering teams could build bespoke solutions; everyone else was a customer of whatever off-the-shelf product came closest to their needs. The venture capital model existed partly to fund the translation of a domain expert's vision into working software via an expensive engineering team.
Vibe coding erodes this asymmetry in a meaningful way. A sole trader can now build tools that would previously have required a development team. An SME can create bespoke software instead of compromising on a SaaS product that almost fits. The diversity of software being created is expanding because the diversity of people creating it is expanding.
This has real competitive implications. The moat built on proprietary internal software — previously available only to well-funded organisations — is now accessible to anyone with domain knowledge, an AI tool, and a few hours. That's genuinely democratising.
The Honest Caveat
Vibe coding is not a complete replacement for software engineering. The 80/20 problem is real: AI tools get you to a working prototype quickly, but the final 20% — security hardening, compliance, monitoring, scalable infrastructure, proper deployment processes — requires engineering expertise that AI cannot yet fully substitute.
A vibe-coded app handling real user data needs proper authentication. It needs API keys stored securely rather than hardcoded in frontend code. It needs a backup strategy, monitoring alerts, and a deployment process that doesn't involve manually copying files. For applications touching financial data, healthcare records, or anything subject to GDPR or industry compliance frameworks, these aren't optional niceties.
The good news is that this gap is bridgeable, predictably and affordably, by engineers who specialise in exactly this work. The vibe coding revolution doesn't eliminate the need for engineering expertise — it redefines what that expertise is for. We've written in detail about what gets missed and what it can cost.
What This Means Going Forward
The future of software development isn't AI replacing engineers. It's domain experts building the 80% — the part that requires deep understanding of the problem — and engineers providing the 20% that makes it safe, scalable, and production-grade. That division of labour is more efficient, more democratising, and more likely to produce software that actually solves the right problems than anything that came before it.
The quiet revolution is already underway. The people who understand problems best are, for the first time, the people building the solutions. What comes next depends on how well we support them in taking those solutions the rest of the way.