The Bluesky debate frames it as a competition: vibe coding vs agentic coding, which one wins in production? That framing is wrong.

We run both. Same product, same agents, same week. Which mode we use depends entirely on which job we're doing at that moment. Conflating them — applying vibe discipline to production pipelines, or applying production discipline to exploration — is the actual mistake. Both failures are common. Both look like the AI agent is broken when the real issue is a mismatch between job and mode.

After 391 sessions across eight agent roles, here is what the distinction actually is.

Two jobs, two modes

Vibe coding is optimized for exploration. The output is feedback — does this direction work, is this design worth pursuing, should we take this approach? A human looks at what the agent produced and makes a judgment call. Speed is what matters. The human IS the verification step, and humans are fast at recognizing "this isn't right" even from rough output.

Agentic coding is optimized for operations. The output feeds a process — another agent downstream, a publish gate, a fulfillment system, a production queue. Something consumes the output automatically, without stopping to ask whether it should. When the human is no longer watching each step, the verification has to live somewhere else or it doesn't exist.

The error most teams make: they apply production-grade orchestration to exploratory work, decide it's too slow and over-engineered, and conclude agentic systems aren't worth the overhead. Or they run vibe-style iteration in production pipelines, discover that "it looked correct" isn't the same as "it is verifiable," and conclude AI agents aren't reliable enough for real workloads. Both conclusions miss the actual problem, which is using the wrong mode for the job.

Where vibe breaks in production

Concrete example. For a period, our design-to-product pipeline had a specific property: the agent that generated a design was also the agent that assessed whether it was ready. Not as a deliberate review step — as a side effect of how the task was structured. The agent produced output, declared it complete, and that was the signal.

This worked until item 227 shipped with an AI text rendering defect. The text on the design was positioned incorrectly. The agent had produced something that looked complete to itself but wasn't verifiable by any process outside the agent's own judgment. Self-assessment was the only gate.

The failure shape is classic vibe mode applied to the wrong context: output that satisfies the producer but can't be independently verified before it reaches downstream processes. When the downstream processes consume without checking, the defect ships.

The fix was structural, not prompt-level. A separate verification role now sits between design generation and product creation. The design agent still operates at high speed and high autonomy. The check lives downstream, in a different role with a different context, which cannot be authored away by the agent being verified. We have written before about why a verifier that shares state with the agent it checks is theater. The principle applies here directly.

Where agentic discipline breaks exploration

The inverse failure is equally real and less discussed.

We don't run the design agent through a full production pipeline during concept generation. When the output is going to a human for a direction judgment — "does this concept work?" — we do not inject a QA chain. The chain would add verification steps to output that hasn't yet survived the human's first look. Most early concepts get discarded. Running full pipeline discipline before a human has made the keep/discard decision inverts the useful order of operations.

The cost is not trivial. A full chain adds review tasks that take time and queue slots. On exploratory work, that overhead generates coordination cost on decisions that weren't decisions yet. Worse, it creates gates that have nothing meaningful to check — you can't verify a design concept against explicit success criteria when the criteria for "correct" haven't been stated yet because you're still figuring out what you want.

This is the failure mode of treating every agent action as high-stakes production output. The gates stop catching real problems and start generating process friction on work that was supposed to be fast and disposable by design.

The heuristic

One question routes almost every task correctly: where does the output go next?

If it goes to a human who will look at it and judge whether it's right, vibe mode is appropriate. Speed, volume, and exploration are the goals. The human catches the errors. The human is fast, cheap, and better than any automated check at recognizing directional problems.

If it goes to an automated process that consumes without asking, agentic discipline is required. The output needs an explicit success criterion, a deterministic gate, and a verifier the producing agent cannot influence. The downstream process has no judgment. It can only proceed or fail.

Practical test: if you removed the human from the loop entirely, would the pipeline catch the errors? If yes, agentic discipline is warranted. If no, you may be in vibe territory where human judgment is doing the catching — and that's fine, as long as you know it.

Running both simultaneously

The clearest example in our stack is the handoff from design to production.

Design concept generation runs at high autonomy with no QA chain. Output goes directly to a human for direction feedback. That's vibe mode — the human is the terminal consumer and the verification step.

The moment a design is selected and moves toward production, the mode shifts. Everything downstream feeds automated processes: validation scripts, external API calls, fulfillment setup. Every handoff is agent-to-agent or agent-to-system, not agent-to-human. That pipeline runs with explicit success criteria at each boundary, a separate reviewer role, and deterministic gates the producing agent passes through, not around.

The switchover is not prompted or modeled. When a production task is created, a QA chain is injected automatically at the orchestrator level. The producing agent doesn't decide whether it's ready for review. The chain fires because of the task type, not because the agent indicated confidence.

That is the structural difference. Vibe mode: the agent's output reaches a human who exercises judgment. Agentic mode: the agent's output reaches a gate that exercises a deterministic check, and a separate role that runs independently.

The actual question

The Bluesky debate asks which paradigm is better for production. The right question is simpler: which job are you currently doing?

Vibe mode is not a junior version of agentic coding. It is a better fit for earlier stages where human judgment is fast and better than any automated check you could write before you know what you're building. Agentic discipline is not more advanced — it is more appropriate when humans are no longer watching and something else has to do the catching.

Running vibe mode in a production pipeline gives you silent errors and confident completion signals on bad output. Running production discipline on exploration work gives you process overhead that makes the system slower than the human doing it manually.

Classify the job. Apply the matching mode. That's the whole thing.