You Merged That. Why.
The unglamorous part of vibe coding nobody posts about — when the merge queue moves faster than anyone can understand what's actually in it.
Critique
Essay
You merged that.
Why the merge queue outran review
critique.sh
Agent harness · BYOA · Composer 2.5
Three Claude sessions. Nobody read end to end. Production incident at 11pm.
Stop shipping straight bullshit and calling it velocity.
You knew it wasn't ready. You merged it anyway.
Not because you're lazy — because you had four other PRs open, a teammate pinging you, and the AI wrote something that looked clean on first scroll. Good enough. Ship it. Figure it out later.
This is the unglamorous part of the vibe coding era nobody's posting about.
Stop shipping straight bullshit and calling it velocity.
The part Andrej didn't mention
Vibe coding unlocked something real. You can go from idea to working feature in an afternoon. The barrier is basically gone. That's not hype — that's just true now.
But here's the thing: the model doesn't know your codebase. It doesn't know what broke last month, why that auth flow is structured that way, or that you should never touch the billing reconciliation logic without three eyes on it. It knows what looks plausible. It's optimising for plausible.
What actually happens to your PRs
Here's a scenario that's probably familiar:
Then something downstream breaks and it takes two hours to trace it back to that PR because the logic was subtly wrong in a way that only shows up under a specific condition that nobody tested.
Senior engineers started calling this "development hell" — inheriting AI-written code where nothing is obviously wrong until it is.
If nobody on the team can explain the PR in one sentence, it doesn't merge.
What Critique actually does
Critique spins up an ephemeral sandbox, runs your code, and catches the breakage before it touches production. Not vibes — actual sandbox verification. Build proof. Type proof. A real block with cited evidence if something's wrong.
Runs the code before merge
Ephemeral environment on the PR head SHA. Build, typecheck, tests — real exit codes, not "looks fine on scroll."
Review lanes, not one blob of comments
Scout maps the change. Security, billing, performance — each lane inspects a different dimension. Lead agent gives a verdict.
Merge policy as code
Define what has to be true before anything merges. Critique enforces it. No seat-based pricing tax when you're not a 200-person eng org.
Agent runs from your pipeline
Fire runs from CI, cron, internal tools. Clones the repo, runs the fix, opens a draft PR, hands it back for review.
If it blocks, it tells you exactly why and where. Whole loop.
This is genuinely the missing piece
Who gives a shit about this
- Solo dev pushing to prod without a real review step.
- Small team drowning in PRs — everyone's also the reviewer.
- Founder who gave junior devs AI tools and said go fast.
- OSS maintainer with contributor PRs stacking faster than you can look.
- Anyone whose merge queue moves faster than their ability to understand what's in it.
- You've merged something you knew wasn't ready.
- A production incident traced back to an AI-written PR nobody read end to end.
- Teammates approve in minutes because they're swamped too.
- You can't explain why the auth flow works that way — the model decided.
- "Figure it out later" became "debug it at 11pm."
You're already building fast. Critique is just the part that checks if what you built is actually good.
Stop merging bullshit.
Sandbox verification, specialist review lanes, merge policy as code — built for teams whose merge queue moves faster than their ability to understand what's in it.
Try Critique → critique.sh