From Vibe to Agentic Coding

There's a difference between using AI to write code and using AI to build software.

Vibe coding

Vibe coding is what most people start with. You describe what you want in a message, the agent writes something, you look at it, you ask for changes, it tries again. No plan. No spec. No structure. Just a long conversation that hopefully ends with working code.

It's fast to start. It doesn't scale.

The context an LLM can process is limited. A 200k token window — the standard context window for most LLMs — holds roughly 150,000 words, about the length of a medium novel. That sounds like a lot, but a long chat plus several open files plus tool outputs fills it faster than you'd expect.

As the feature gets more complex, the conversation gets longer. The agent starts forgetting what it decided three messages ago. It contradicts itself. You spend more time correcting than building. The codebase becomes whatever the last prompt happened to produce.

What changes with an agentic workflow

An agentic workflow doesn't just use AI to write code — it uses AI deliberately. The key differences:

You plan before you build. The spec exists as a file, not just a message. The agent reads it at the start of every session — so it never forgets what it was supposed to do.

You work one feature at a time. The scope is bounded. The agent knows what it's building and what it's not.

The agent can verify its own work. With the right tools wired up, it builds, runs tests, reads errors, and fixes them — without you copying error messages back and forth.

The specs are your project memory. Close the chat, open a new one, new model, new harness — the agent reads the same files and picks up exactly where you left off.

The mindshift

Vibe coding feels fast because you skip the planning. Agentic coding feels slower at first because you do the planning. But the planning is what makes the agent useful — and the agent makes the planning worthwhile.

You're not writing less. You're writing differently. Specs instead of code. Architecture instead of syntax. Reviews instead of typing.

The output multiplies. The thinking stays yours.