Skip to content
AI agents & MCP

Vibe Coding vs Planned Coding: Where Teams Draw the Line

By Sebastiaan Jansen · · 9 min read

Vibe coding means prompting an AI coding tool, accepting what it writes, and going back and forth in the chat until the screen looks right. That's a fine way to explore. It's a bad way to ship code that other people will run, review, and maintain. Teams draw the line at anything that touches shared code, customer data, or a promise already made to a client.

In practice, a developer describes the outcome loosely, lets the model choose the files and the structure, and then keeps typing "fix the error" until the happy path works. Nobody writes acceptance criteria, and there's often no test that would fail for the right reason. It feels fast because the feedback is visual and immediate.

What vibe coding actually means

Almost every session has the same three moves:

  • The prompt describes a vibe ("a clean settings page like the one we saw") rather than a contract (who can edit billing, what happens when the card fails).
  • The developer steers by running the app and pasting in the next error. Nobody reads the diff against a plan.
  • Success means "it works on my machine in this branch." Whether another engineer can merge it on Thursday doesn't come up.

For a prototype, that loop makes sense. A founder checking whether a flow is understandable, or an engineer spiking a library for an afternoon, learns more from a running screen than from a design doc. If they're wrong, they lose an hour and delete a branch.

On the main repository the same loop gets expensive. The model doesn't remember last quarter's incident, the billing edge case support already documented, or the rule that migrations ship in their own pull request. It invents a structure that looks plausible, and that structure usually isn't the one the team already uses.

Planned coding starts from the other end. Someone writes down the outcome, the constraints, and which files are in bounds. The agent may still write most of the lines, but a person (or a workflow rule) decided the shape before the first edit.

Vibe coding risks teams hit after the demo

Demos are where teams get fooled. The page loads, the button works, and everyone in the room relaxes. The problems arrive in the next pull request, or two sprints later when someone else has to change the feature.

Unowned structure. The model creates helpers, hooks, and folders that fit the prompt instead of the repo. The next agent copies that pattern because it's now in the tree, and you end up with two styles of data fetching side by side. Reviews get longer because every change reopens the argument about which style is allowed.

Happy-path tests. Generated tests often assert against the sample the prompt used. They pass while the empty state, the expired session, and the partial failure are still broken, so the green check doesn't prove anything.

Silent scope. "Add export" turns into a new dependency, a background job, and a table. Nobody estimated any of that, because nobody wrote down the boundary. The ticket, if there is one, still just says "add export."

Review theatre. A large diff written in one session is hard to review properly. Reviewers skim it, comment on names, and approve, while the defect sits in a file they never opened. AI code review helps with style and obvious bugs, but it can't replace a person who knows why the change exists.

No rollback story. If the only record of intent is a chat log on one laptop, the on-call engineer can't tell a bad deploy from a bad idea. DORA's software delivery metrics treat change failure rate and time to restore as first-class outcomes, and a workflow that can't explain its changes makes both worse, even when the first deploy looked fine. All five of these show up when code gets generated faster than people agree on what it should do.

Where teams draw the line

The question isn't whether to use AI. It's which decisions have to be made before anyone writes code.

Decision Vibe coding Planned coding
Goal A feeling, revised in chat A sentence a reviewer can test
Scope Whatever the model touches Named files, modules, or a ticket
Data and auth Often discovered at runtime Named up front, including who must not see it
Tests Added after the UI looks right Written against the failure you care about
Review Optional, or a rubber stamp A person who did not write the prompt
Record Chat log Ticket, plan, and pull request linked together

Here's a rule many teams can adopt without buying anything:

  1. Spikes can be vibe-coded. They stay on a throwaway branch and never get merged.
  2. Anything merged to the shared branch needs a ticket with acceptance criteria, even if that's five lines.
  3. The agent works from that ticket and the repository, not from a fresh chat with no context.
  4. A human reviews the diff against the criteria, not against the demo.
  5. Production access, migrations, and billing changes stay behind a human, however confident the model sounds.

Context is the other half. An agent that can read the repo, the open ticket, and the team's rules will still make mistakes, just fewer avoidable ones than an agent that only sees the last message. How teams keep that context shared is covered in AI coding agents and Claude Code for teams. The short version: the system of record is planning and tickets, not someone's private chat.

A worked example: the same feature, two ways

A support lead asks for "a way for admins to pause a workspace." The product is a B2B app where workspaces have members, an owner, and a monthly invoice. Pausing should stop invites and scheduled jobs without deleting any data.

The vibe-coded afternoon. The engineer prompts: "Add a pause button on the workspace settings page. Make it obvious. Stop things from running while paused." The model adds an is_paused boolean to the workspace row, a button, and a check in the invite handler. The engineer runs the UI, asks for a red badge, and opens a pull request of about 400 lines. It gets reviewed on Friday.

Because nobody wrote these down, the diff missed them:

  • Scheduled jobs check a different service, which never reads is_paused.
  • The owner can pause, but so can every admin, including a contractor role that wasn't supposed to.
  • Nothing says what happens to an open invoice if you pause mid-cycle.
  • The audit log gets no event, so support can't answer "who paused us?"
  • The badge is the only test. A unit test asserts the button label.

On Monday the bug is obvious: jobs keep sending mail for a paused workspace. The fix comes from a second chat session, which adds a second flag in the job service. A month later the two flags have drifted apart.

The planned version of the same request. Before anyone edits a file, the ticket says:

  • Only the workspace owner can pause and resume.
  • Pause sets one column, paused_at. Null means active.
  • Invite creation and the job runner both refuse work when paused_at is set, through one shared function instead of two flags.
  • Open invoices are unchanged. Pause does not credit or cancel.
  • An audit row records actor, workspace, and timestamp.
  • Tests cover: member cannot pause, owner can, invite fails while paused, job skips while paused, resume clears paused_at.

The engineer, or an agent, builds against that list. The diff is smaller because the non-goals are spelled out, and review just checks the list. The support lead can read the ticket and see that invoices are out of scope, which was the conversation they needed to have anyway.

A coding agent can still write every line of the planned version. The plan is what makes that speed safe to merge. Compare the two by how much rework each one caused, not by which got a green build first.

How planned coding uses AI without skipping the plan

Planned coding doesn't mean going back to six-week design phases. It means a short written contract and an agent with limits.

Write the contract where work already lives. A ticket with a type, a stage, and acceptance criteria is better than a plan buried in a doc nobody links to. If the request came in as a Slack thread, a call, or a production error, turn it into a ticket a reviewer can accept or send back. If it stays in chat, you will get a second, different version of the requirement.

Constrain the write. "Change the workspace module and its tests" is a better instruction than "implement pause." Version-checked writes matter too: if the file the agent read has changed since, the write should fail instead of overwriting a teammate's edit with a stale copy.

Keep rules in the workflow, not in a prompt someone has to remember. Naming, migration policy, and who may touch billing belong next to the repo and the ticket. A prompt can repeat them, and it will also forget them next session.

Review the plan, then the diff. Planning agents are most useful when a person accepts the plan before the branch exists. That review is short, and it would have caught the double flag before anyone wrote it. The order is context, plan, edit, then a human merges.

Measure the boring outcomes. Cycle time from ticket start to merge, and the share of changes that need a follow-up fix, tell you whether the line is in the right place. If spikes are fast and merged work is calm, it's working. If merged work keeps needing a second ticket called "fix the pause flag," the line has slipped.

Tooling can keep the ticket, the plan, and the repo context in one place. Falrow is one workspace built for that: requests become tickets, and Claude Code and Codex plan from the git repository using a catalogue of MCP tools, with the team's workflow rules applied to every write. The habit counts for more than the vendor, though. A shared board, a written criterion, and a review step already beat an unlogged chat. The MCP server is just the pipe that lets an agent read that board and that repo instead of guessing.

AI project management fails in the same spot, when the tool generates status updates and nobody owns the decision. Forecasts, stages, and agent plans are only as good as the tickets underneath them.

FAQ

Is vibe coding the same as using an AI coding agent?

No. An agent writes code from instructions, and vibe coding is one way of giving those instructions: loose prompts, visual checks, and no agreed scope. The same agent can follow a ticket, a file list, and a test plan. Which approach you use is a team decision, not something the tool decides.

When is a loose AI session worth it?

For throwaway spikes, personal scripts, and learning a library you won't ship. Keep the branch off the main line. If the spike proves the idea, write the outcome up as criteria and build it again under review. Unowned structure gets in when people merge the spike to save time.

What usually breaks after the demo is merged?

Usually it's unowned structure, tests that only cover the demo, scope nobody estimated, weak review of a huge diff, and no record of intent when something breaks. The production failure tends to be ordinary: a second flag, a permission that's too wide, or a job that never learned about the new state. What you pay for is rework and unclear ownership, not some mysterious AI failure.

Do we have to stop using Claude Code or Codex?

No. Planned coding is those same tools with a ticket, a boundary, and a review. Teams keep the speed of generation without treating the chat as the specification. If your agents already open pull requests, put the acceptance criteria in the ticket they read, and make sure a human is the one who merges.

More on ai agents & mcp