Vibe coding and agentic coding: where the engineering still is
AI already writes code faster than you can. What decides whether the system lasts is the design, tests and review around it.
Writing code is no longer the bottleneck. With a language model, describing an endpoint and having it running takes minutes. What still costs time is what comes next: a system that survives errors, grows without breaking and can still be changed two years from now.
That difference separates two ways of working with AI that are easy to confuse: vibe coding and agentic coding.
Vibe coding: speed without a net
In vibe coding you talk to the model. You describe what you want in plain language, the model generates code, you try it, adjust and repeat. You don’t need to know the syntax or the architecture to reach something that works.
To validate an idea, put together an interface or ship a prototype, it’s an excellent tool. An MVP that used to take weeks can exist by the weekend, and sometimes that’s exactly what you need to learn whether the product is worth building.
The trouble starts when the prototype stays. With no design up front, the model solves the happy path and little more. What we usually find in those projects:
- Coupling. Business logic, data access and the interface live in the same components.
- Fragility. No handling of async errors, no backups, no validation of what users send.
- Code nobody understands. Every change is asked of “the conversation”, context gets lost and upgrading a dependency becomes a gamble.
The savings on day one are paid back later, with interest, in maintenance.
Agentic coding: AI inside a framework
In agentic coding the AI is not an autocomplete. It’s a team of agents that implements specific pieces within constraints someone defined beforehand. The order flips: design first, code second.
Your job moves from typing syntax to orchestrating:
- Specify. You write what each component must do and how it connects to the others: how a backend talks to a queue’s workers, how containers are built so development and production match, how CI/CD runs.
- Constrain. The agent works with rules it can’t skip.
- Verify. Nothing is accepted without going through review.
There are three of those controls, and they are the same ones you would already demand from a person:
| Control | What it prevents |
|---|---|
| Static analysis (linters, strict types) | Code that ignores the project’s conventions even reaching review |
| Automated tests (unit, browser) | “It looks like it works” with nobody having checked |
| Human review of every PR | Vulnerabilities, race conditions and bottlenecks a model doesn’t see |
What it looks like in practice
This site is a small example. It has measurable goals (A+ on security headers, Lighthouse ≥ 95, AA accessibility), an AGENTS.md that sets the rules for any agent or person, decisions recorded as ADRs, strict types, ESLint, unit and browser tests, and a CI that must be green before deploying. Nothing is ever pushed straight to main.
With that framework, AI speeds up implementation and mistakes surface early, because there is something to compare against. Without it, the same tool would produce the same pace and far less confidence. The speed comes from the tool; the confidence, from the framework.
What still matters
Automating code writing doesn’t remove the need for engineers: it changes where their judgment shows. We think what pays off most today is understanding the pieces the model doesn’t decide for you:
- database design and what it takes to change it later;
- concurrency, where bugs only show up under load;
- secure deployment: secrets, permissions, backups and what happens when something fails.
Whoever masters those abstractions can hand the technical carpentry to an agent and review what matters. Whoever doesn’t gets code that looks right and has no way of knowing if it is.
When to use each
| Situation | Approach |
|---|---|
| Validating an idea, a prototype, a throwaway demo | Vibe coding, with the expiry date in sight |
| A product that will have users, data and maintenance | Agentic coding, with design, tests and review |
| A prototype that “worked” and you now want in production | Treat it as a specification: redesign it before it grows |
Programming has been democratized, and that’s good. Software engineering, the discipline of building systems that are secure, scale and tolerate failure, is still design work that a tool, on its own, won’t do for you.
Have a prototype built with AI that you want to take to production, or a new project and you’re unsure how to frame it? Tell us what you need and we’ll look at where to start.