Vibe Coder
Direct AI agents that write the code. You own the spec, the taste, and the ship button.
A vibe coder builds and ships real software by directing AI coding agents — Claude Code, Codex, Cursor, Antigravity — instead of typing most of the code by hand. Andrej Karpathy coined the term in early 2025, half-jokingly, for coding without reading the diffs; by 2026 it names a serious discipline with the joke removed. The craft moved up a level: you write specifications, hold architectural taste, verify relentlessly, and orchestrate several agents in parallel. The agent owns the keystrokes. You own everything that matters — what gets built, whether it's right, and whether it ships.
The role exists because agentic coding crossed a threshold: from autocomplete to delegation. Teams discovered a brutal spread between people who use these tools casually and people who run them well — same tools, wildly different output. So companies began hiring for demonstrated agent leverage directly: 'AI-native developer' and product-engineer listings now ask how you work with agents, not whether. Meanwhile the solo path became real. One person with good taste and a fleet of agents can ship what used to take a team — and either sell it as a product or sell the capability as a service.
It is not prompt engineering — you ship products, not prompts. And it is not just 'software engineer, but faster.' The unit of work changes from the function you write to the task you delegate, so the scarce skills change too: writing specs an agent can't misread, reviewing diffs fast without rubber-stamping, building verification harnesses so agents check themselves, and knowing precisely when to grab the keyboard. People with all four skills are still rare, which is the whole opportunity. This roadmap builds them in order.
- Turn fuzzy product ideas into written specs an agent can execute: acceptance criteria, edge cases, and explicit non-goals.
- Run two to five agent sessions in parallel across git worktrees, slicing features into agent-sized tasks that don't collide.
- Review AI-written diffs fast and honestly — read every line that touches auth, money, or data deletion; skim the rest with tests as backstop.
- Maintain an agent-legible codebase: CLAUDE.md conventions, memory files, and docs that make every next session smarter.
- Build the verification harness — types, tests, lint, CI — and wire agents to run it themselves before showing you anything.
- Ship to production and stay there: monitoring, error triage, and fixes with the agent in the loop.
- Re-evaluate the tool stack monthly; models and harnesses move fast enough that last quarter's workflow is stale.
- Drop to hand-written code when the agent is flailing — and recognize that moment early instead of burning three more sessions.
- You think in outcomes and constraints, not syntax; writing a crisp spec feels like the real work.
- You'd rather review three diffs than hand-write one function.
- You can smell plausible-looking slop — code that compiles, skims well, and is still wrong.
- You ship side projects habitually, and you finish them.
- You have the patience to verify: nothing merges because 'the agent seemed confident.'
Foundations: code + agents
Weeks 1–4You can't direct what you can't judge. Learn enough code to read it critically, then get your first agent shipping under your direction.
Specification and memory
Weeks 5–8The core law of the craft: bad agent output usually means your spec was ambiguous. Learn to write instructions that survive contact.
Verification and taste
Weeks 9–14Speed without verification is how vibe-coded products die in public. Build the review skill and the harness that makes speed safe.
Orchestration and scale
Weeks 15–20One session is a skill; a fleet is a system. Parallelize safely, delegate to subagents, and keep cost per feature visible.
Ship, prove, get paid
Weeks 21–28The market pays for shipped products and legible process. Get real users, publish how you work, and pick your monetization path.
Nobody hires a Vibe Coder off a certificate. They hire off proof. Ship these and put them where people can click them:
“I ship production software by directing AI agents — [N] products live, [X]% agent-written, verified by a harness I built.”
- Shipped [product] to [N] users solo in [X] weeks by running three parallel agent streams; [Y]% of merged code was agent-written.
- Cut feature cycle time from days to hours with cold-handoff specs that land in at most two correction rounds.
- Built a verification harness — types, tests, lint, CI — that agents run themselves; [N] releases with zero rollbacks.
- Found and documented [N] agent-introduced defects pre-ship, each traced to a spec or harness fix.
- Held cost per shipped feature to $[X] across [N] features by routing models and scoping sessions deliberately.
- Build in public with real logs — prompts, corrections, costs — not hype threads. Legible process is the differentiator; everyone else posts screenshots.
- Pin the product repo, its spec, and its CLAUDE.md together on GitHub; the README leads with what it does and who uses it.
- Publish one honest failure teardown for every win — the defect-hunt post outperforms the launch post with hiring managers.
- Ship where builders watch: demo days, launch platforms, and the communities around your agent stack.
- Contribute agent-workflow writeups or small PRs to the tooling you use — the ecosystems are young enough that one good contribution gets noticed.
- A live agent-driven build while they watch: spec it, delegate it, review the diff out loud. They're grading your corrections, not the agent's code.
- A diff-review round with planted bugs. Read auth, money, and deletion paths line by line — that habit is the pass signal.
- A process deep-dive on your build log: what did you decide versus the agent? Own the architecture calls explicitly.
- System design framed as delegation: what you hand the agent, what you write yourself, and why.
- On the solo path there is no interview — the build log and the revenue are the pitch. Package them like it.
Is vibe coding a real job or just a meme?
Both, which confuses people. The meme is coding without reading the output. The job — posted as AI-native developer or product engineer — is directing agents with rigorous specs and verification, and companies now screen for it explicitly. There's also a real solo path: one person shipping revenue-generating products with agent leverage.
Do I still need to learn to code?
You need to read code and judge it, which is a smaller but non-optional subset of learning to code. Skipping it caps you at demos: the first production bug, security review, or gnarly migration ends the run. The good news is you can learn to read critically much faster than you can learn to write fluently.
Won't this job be automated away too?
The typing already was — that's the premise. What remains is deciding what to build, specifying it, and verifying it, and those move up in value as execution gets cheap. If agents improve tenfold, the person who directs them well ships tenfold more. The role transforms; it doesn't vanish.
How is a vibe coder different from a prompt engineer?
A prompt engineer optimizes model interactions that live inside a product. A vibe coder ships whole products, using agents as the workforce. The overlap is prompting skill; the difference is that your deliverable is working software in production, with everything that entails — architecture, review, ops.
Which tool should I learn first?
Pick one deep rather than three shallow — Claude Code is the most common choice for serious work and this site's core track. The concepts (specs, memory, verification, orchestration) transfer to Codex, Cursor, and Antigravity almost 1:1. Add a second tool in month two to prove that to yourself.
Every stage above maps to free lessons on this site. No signup, no paywall — open the first course and ship your first checkpoint this week.
Browse the courses →