Skip to content
InsyteGroup
All insights

Technologies

Anyone can vibe code now. Shipping software is a different job

Nazarii Kalichynskyi

7 November 2026 · 8 min read

Describe an app in plain English and an AI will build it for you. That is a genuine shift. But a working prototype and software a business can rely on are not the same thing. The difference is everything a proper development pipeline does around the code, and it is why our agentic development is supervised by experienced engineers.

In February 2025, Andrej Karpathy, a founding member of OpenAI and former head of AI at Tesla, gave a name to something a lot of people had started doing: vibe coding. You describe what you want in plain English, an AI writes the code, you run it, and if it works you move on. You don't read the code. You don't really need to. By the end of the year it was Collins Dictionary's Word of the Year.

It deserves the attention. Someone with no development background can now build a working prototype in an afternoon: a tracker for the team, a quoting calculator, a dashboard over a spreadsheet. Ideas that would once have sat on a wish list for months get tried the same day. That is a real change, and it is not going away.

We use agentic development every day, and it is easy to confuse with vibe coding. Both use AI to write code. The difference is who is in charge. Vibe coding hands the outcome to the AI: you don't read the code, and if it runs, it ships. Agentic development keeps experienced engineers in charge: the AI writes much of the code, but an engineer decides what gets built and the patterns it follows, reads every change, and puts it through the same testing, security and release steps as any other software.


A prototype is not a product

A vibe-coded app is built to work once, for the person who built it, on the happy path. Production software has to keep working: for every user, with real data, when someone does something unexpected, after the source system changes, and when the person who built it has moved on.

That gap is what a classic software development pipeline exists to close. It has been refined over decades, and every stage is there because something once went wrong without it:

  1. Requirements. What the software must do, for whom, and what happens at the edges.
  2. Design. How it fits together: the data and application architecture, where it runs, how people sign in, what it connects to.
  3. Build and test. Automated tests are written alongside the code, test-first where it fits, so every piece proves itself as it is built.
  4. Review. Someone other than the author reads every change, and the tests must pass before it goes in.
  5. Acceptance testing. Does it work for the people who will use it, end to end and against real scenarios, up to and including user acceptance testing (UAT).
  6. Security. Secrets kept out of the code, access controlled by role, inputs never trusted.
  7. Release. Changes go live deliberately, with a way back if something goes wrong.
  8. Run. Logging, monitoring and support once people depend on it.

Vibe coding can make it feel as though all eight have been done. Ask for tests and you get tests. Ask whether it is secure and you are told it is. In reality, most of the stages have been skimmed rather than done: the AI covers what it was asked about, not what an experienced engineer would know to check.

Five things come up again and again when we look at vibe-coded apps.

It works, but not well. The first version runs, but it is often inefficient. Database queries that fetch far more than they need, or run once for every row instead of once for the page, are common. With a handful of records nobody notices. With real data, the app slows to a crawl. The AI can usually improve it, but it rarely does unless someone explicitly asks.

Code sprawl. When the AI needs something it has already written, it will often write it again rather than reuse what is there. The same block can turn up in several places, so a change has to be made in each of them, and the one that gets missed becomes the next bug.

Every problem is solved a different way. Without someone setting the patterns, the AI solves each new problem from scratch: three ways of calling the same system, two styles of handling the same kind of error. It all works, but nobody can learn one part and understand the rest.

Fixes become plasters. Ask an AI to fix a bug and it fixes the symptom in front of it, not the cause underneath. Each fix works, so nobody looks further, and before long the code is covered in small patches that interact in ways nobody planned. It turns into spaghetti, and every change after that gets harder.

Nobody knows how it really works. The person who built it never read the code, so when they move on, there is nobody who can explain it. Not even the AI, which starts afresh every time it is asked.

All five come down to the same thing: the AI does what it is asked, and nobody is checking what it wasn't. Knowing what to ask for is the experience.

AI has made writing code cheap. It hasn't made being wrong any cheaper.


How we use agentic development

In practice, AI agents write code, run checks and make changes inside a pipeline that experienced engineers own from start to finish. The AI does a large share of the typing. The engineers own every decision, and the same rigour applies as it always has.

Requirements start with people, and finish with a prototype. Before anything is built, an engineer agrees with the client what the software must do and how it should fit together. For a commercial HVAC contractor, that meant deciding exactly which quote and job fields the key account managers could change, and that every change would be reviewed on screen before it was written back to Simpro.

From those requirements we build a prototype, then the engineer refines it with the AI. We find the last 20% or so of the requirements are best worked out this way, because it is so much easier to say what you want when you have something in front of you. Better still, we can make those changes live, with the client in the room.

A good prototype is often the best possible requirements document.

Every change is reviewed. Agents work on a separate branch, and their work comes back as a pull request that an engineer reads before it goes anywhere, just as it would be if a colleague had written it. If we can't explain a line, it doesn't ship. When something breaks, the engineer finds the root cause rather than accepting the first patch, and performance is checked against realistic volumes of data, not a handful of test records.

Tidying up is part of the job. Once a feature works, we go back through the code with the AI, looking for repeated blocks and opportunities to modularise. Shared logic is pulled into one place, so the next change is made once, not in several places. It is the step a vibe-coded app never gets, and with AI doing the legwork it no longer costs much to do properly.

Testing is planned, not hoped for. This is where agentic development shines. During the build, agents write the unit and integration tests alongside the code, test-first where it fits, and run them on every change. Then they go further: they spin up Playwright, open the app in a real browser and work through it the way a user would, clicking, filling in forms and checking what comes back. When something goes wrong, they record a short video of it, so the engineer sees exactly what happened.

It is not user acceptance testing, because there is no real user. But it is close to AI-driven UAT, and it means that what goes to the client's people for proper UAT arrives with far fewer holes in it. The engineer still decides what needs proving. Figures are checked against the source system, and the edge cases are listed and worked through with the people who will use the software.

Security is designed in. Sign-in goes through the client's existing identity provider, access is set by role, secrets live outside the code, and anything a user or an AI model sends in is treated as untrusted. None of that appears in a vibe-coded app unless someone knows to ask for it.

Releases are deliberate. Changes are reviewed and agreed before they go live, and checked again once they are. Our apps run in Azure, with logging and auditing, so when something does go wrong we can see exactly what happened.

It is the same approach we described for Power BI: AI speeds up the build, and people bring the understanding and the craft.


How much should the agent do on its own?

That is the question we are working through now. We are trialling three ways of working on real projects, each starting from a Jira ticket that sets out the requirements:

  1. Ticket to pull request. The agent takes the ticket and works all the way through to a pull request on its own. The engineer reviews the finished change.
  2. Small steps, reviewed at each one. The ticket is broken down into smaller tasks, each with its own pull request and a detailed review before the next one starts.
  3. A hybrid of the two. The agent works more independently on some tasks, and is reviewed step by step on others.

Each trades speed against control in a different way, and so far we have settled in the hybrid, with the balance set by the kind of work:

  • Front end. With a good design system in place, screens, layouts and interactions suit a more agentic approach. The agent can take a ticket a long way on its own, and the result is easy to see and check.
  • Back end. A human stays in the loop along the way, with smaller steps and a review at each one.
  • Complex back end with lots of business logic. Here the engineer starts by hand, establishing the patterns, the structure and the core rules. Once those are right, the agent extends them, and it follows patterns far more reliably than it invents good ones.

Either way, an experienced engineer reviews the work before it ships.


What this changes for our clients

The biggest change is what is now worth building. A custom app used to be a large investment, so most businesses made do with spreadsheets or bent an off-the-shelf product to fit. With agentic development, a first working version arrives in days rather than months, and more of the engineers' time goes into understanding the business, testing and security.

That is why we now build custom apps alongside Power BI: a quotes and job forecasting app that writes straight back to Simpro, or our own sales and marketing app that updates HubSpot from the dashboard. A few years ago, most clients would not have considered either worth the cost.


Where vibe coding fits

Vibe coding is a brilliant way to try an idea. If you want to know whether a tool would help your team, build a rough version and use it for a week. You will learn more than any requirements document could tell you.

The line is real data and real people. As soon as an app holds customer information, writes to a system the business runs on, or has more than a handful of users depending on it, it needs the pipeline. That doesn't mean starting again: the prototype is the best place to finish the requirements.

Anyone can build software now. Building software a business can rely on is still a job for people who know what can go wrong, and the AI makes that job faster, not optional.


What others are saying

The wider evidence points the same way:

  • The person who coined it set the limit. Karpathy's original post described vibe coding as fine for throwaway weekend projects. That fine print got lost as the term spread.
  • Not all AI-assisted programming is vibe coding. Developer Simon Willison limits the term to building software with AI without reviewing the code it writes. His rule for production code is the same as ours: nothing is committed that he could not explain to someone else.
  • AI-generated code often has security flaws. When Veracode tested more than 100 AI models on 80 coding tasks, around 45% of the code introduced a security flaw, and models getting better at writing working code did not make it more secure.
  • Duplication is rising. GitClear analysed 211 million changed lines of code and found an eightfold rise in duplicated blocks during 2024, as AI assistants spread. It is a vendor's report, but it matches the code sprawl we see.
  • AI amplifies what is already there. Google's 2025 DORA report found that 90% of software professionals now use AI, and that it speeds up delivery but also increases instability unless the practices around it are strong.

Sources

Was this article useful?

Share this articleLinkedInEmail

Want to talk it through?

We’re always happy to talk through what this could look like for your business.

Technologies we work with