Vibecoding vs AI engineering

Two ends of one axis: who holds the verification — and therefore who owns the result.

Vibecoding (Karpathy, Feb 2025, coinage traceable to a captured transcript: “giving the control to Composer and just telling it what to do and hoping that it works… worst comes to worst, you can always fall back to the good old programming”) — the human relinquishes review: accept diffs wholesale, run it, feel the output. The disposition is consumer: software as a conversation whose artifacts you never open. Its honest form is disposable software — throwaway toys, one-off scripts, prototypes you intend to delete. Karpathy himself framed it as a Weekend-at-a-hobby-lane activity, not a practice.

AI engineering (AI engineering) — the same models wrapped in the discipline the vibe lane skips: evals before vibes, context budgeting, crash-resilient workflows, kill-switches, trajectory grading, feedback pipelines. The human disposition is owner: the model drafts, the system verifies, the engineer is accountable for what ships.

The line, drawn precisely

• Stakes — vibe lane: artifacts you can afford to lose. Engineering lane: anything with users, data, or an on-call rotation.
• Verification — vibes: “it ran.” Engineering: LLM evals, tests, checks — the pstack/verification cluster’s whole thesis.
• Reversibility — disposable output vs. maintained systems; the strangler-pattern caution (don’t rewrite what you must keep) applies to both.
• Skill — vibecoding needs taste (can you tell it’s good without opening it?); AI engineering needs judgment about failure (which failure modes matter, what contains them).

The confusion to kill: vibecoding ≠ “using AI to code.” Every serious practice in this vault — pstack’s lints/evals/evidence, Temper’s proved-and-executed specs, Bend’s formal verification, retro’s propose-only check mining — is the opposite of vibecoding while being 100% “AI coding.” The differentiator is not AI usage; it is whether verification survives the session.

The retro bridge (why this note exists)

Matt Pocock’s /retro skill (announcement + captured writeup → clippings/aihero-dev-skills-retro.md) is the cleanest transition ritual between the lanes: after a session, it reads the session’s own record, finds where the agent struggled, and proposes environment fixes, not code fixes — a lint rule for the mistake a tool could have caught, a navigation pointer for the twenty-tool-call search, a standards-file rule for the reviewer, deleted no-ops in steering files. “It changes the environment, not the code… It also only proposes. Nothing changes until you pick a candidate.” Even successful sessions turn up inefficiencies; the struggles are the curriculum, and retro is the practice that converts a vibe session’s lessons into engineering guardrails — mechanical violations → deterministic checks, only true judgment calls → prose. Its honest limits are documented too: it can’t audit rules it proposed last month (you still prune), and severity ordering is a first draft.

That’s the whole relationship in one tool: vibecoding generates the experience; engineering is what you keep from it.

The photographer’s defense (the strongest vibe-lane rebuttal)

Stanko Krtalić (Basecamp/HEY, captured; pointer) — written a week into rewriting HEY in Rust during Rails World, endorsing DHH’s “pencils down” keynote: “David is right. Like it or not, we programmers, like painters before us, are slowly going to disappear. AI, like the camera, completely changed the game. You can sulk about it, or pick up a camera, start learning, and become a photographer.” The evidence: HEY CLI + TUI + SDK vibe-coded in a week (“no human has seen any of the machinations beyond initial setup — and it worked out”); a designer shipping polished ASCII TUIs in a language he doesn’t know; “my only limit now was my imagination.” The honest addendum that keeps it out of pure vibes: “AI removed the speed limit, but it didn’t remove the limits of my imagination. The more you know, the more you can imagine” — his programming knowledge is what caught the non-working designs and steered agents; expertise carries over as taste and oversight, walls between roles break down, “the future needs a more even blend of skills.” And eventual excellence: writing code used to be expensive, now ideas are cheap to try — “five ideas in the time it took to prove one… excellence doesn’t have to happen on the first try” (misfires as exposures, not failures). The civil-engineer reframe: agents pour concrete, engineers design homes — “we have to become makers.” Where this sits on the axis: disposable-lane honesty (a CLI shipped in a week, Rust rewrite velocity) with engineering judgment retained as the photographer’s eye — which is why “learning the camera” (model limitations, expression skill) is the operative demand, not abandoning judgment.

The review-side product: nyk’s Spec Gate (rubrics for agent PRs)

Spec Gate (captured; via @nykdotdev — “green CI does not mean the agent run is cheap. I want a named yes on unbounded loops and model token paths before merge.”) — five review rubrics for coding-agent PRs, each with a 5-min skim path and a 20-min deep path (“use the smallest review that closes your current risk”): 01 security basics (secrets in logs, hardcoded creds, agent-specific exposure patterns), 02 correctness & tests (hollow mocks, tests that claim more than they prove), 03 API & migrations (breaking changes without paths, schema drift), 04 performance & cost (N+1s, unbounded loops, model token waste, “API cost patterns agents introduce”), 05 agent hygiene (commented-out debugging, orphaned imports, invented metrics, hallucinated dependencies). Plain markdown, PR-description template + reviewer reply stubs; no CI integration (deliberately — the product is the human rubric, kin of retro’s propose-only discipline). Position: the engineering lane’s answer to the large-diff problem the vibe lane creates — review structure as the merge gate, cost as a first-class review dimension (the wagtail/GLM-energizer lesson productized).
Related: AI engineering · AI engineering stretch goals · Agent skills (retro as a skill instance) · Do-nothing scripting (propose-only, human decides)
Same lane, new tool — pulls.review (Anthony Fu, 140★, MIT, TS; announcement, 534❤/23k views): categorizes PR changes into logical groups with summaries — “review them one scope at a time,” focusing on what matters. Three integration surfaces: website paste, opt-in GitHub userscript enhancing the PR UI, and a GitHub Action/CLI — with the economics that matter for teams: the CI workflow analyzes each PR once and posts the result as a comment (“instead of each reviewer spending their own model key”; re-runs on unchanged PRs skip the model call). Anthropic/OpenAI-compatible/Vercel-Gateway keys, provider inferred from the key. The engineering-lane review stack assembles: retro (mine the session) → Spec Gate (human rubric at merge) → pulls.review (the diff, pre-chewed into scopes).