All roadmaps

Vibe Coding

Build real software by directing AI - with taste.

The new development loop: describing outcomes, letting AI write the code, and applying the review, testing and product judgement that separates shipped products from abandoned demos.

Your progress0/33 topics · 0%

Progress is saved in this browser.

5 stages33 topics₹0 to follow
Skill certification coming soon

Filled nodes are the focus for this track; outlined ones can wait. Tap a topic to open it and mark it done, learning or skipped.

Vibe Coding in 2026Related roadmapsClaude Code roadmapStartup roadmapJavaScript roadmapProve it as you goReading is half of it. The free, scoredAI Work Competency certification coversthe ground this roadmap leads to, and theFull-Stack Engineer job simulation putsit to work on real tickets - evidence arecruiter can check. Mark topics done,learning or skipped as you go; yourprogress carries into the classic view.AI Work Competency certificationJob simulationClassic viewKnow the demand before thesyntaxVibe Coding in 2026What to learn in 2026Prompting abuilderReading what itwroteShipping safelyWhich roles use itFounders andPMsDevelopers,carefullyFresher vs switcherWhat companies expectThe hiring barWhat interviewstestProof they verifyWhat gets you hiredA 90-day planProjects thatget readCertification and proofUnderstand what changed andwhat didn't.The New LoopWhat vibe coding isThe tool landscapeHonest limitsPrompts that produce products.Directing AIDescribing outcomesIterating in small stepsGiving feedback that landsTrust nothing; verifyeverything cheaply.Verification DisciplineReading AI codeTesting as the contractSecurity & secrets hygieneFrom vibe to deployed product.Ship SomethingDeploy & domainBuilding tasteJust enough fundamentalsFresher or experienced?Both tracks hold every topic. On the Fresher track thefoundations are filled and the later stages are outlined - dothem when a project needs them. On the Experienced track thefoundations are outlined and the later stages are filled. The2026 section at the top applies to both.Prefer a list?The classic view shows the same 4 stages as a sequentialchecklist with time estimates. Your marks are shared betweenthe two views.Open the classic view

Everything on this roadmap

Every stage and topic on the map, in reading order. Click any topic to open it.

The Vibe Coding roadmap, topic by topic

Every topic on the map in reading order, with what to learn and the resources we recommend. Main topics are open; open any subtopic to read it. Select a topic name to open it in the topic panel, where you can track your progress.

  1. 1. Know the demand before the syntax

    Vibe Coding in 2026

    2026

    Vibe coding - describing what you want and letting an AI builder or agent write the code - is how a growing share of software starts in 2026, and how most non-developers now build. The numbers are two-sided: the Stack Overflow 2025 survey found 84 percent of developers using or planning to use AI tools, 52 percent reporting a productivity gain, 46 percent distrusting the output and 45 percent losing time debugging AI-written code, while 72 percent said vibe coding was not part of their professional work. The skill, then, is doing it well: prompting a builder precisely, reading what it wrote, and shipping safely. The four nodes answer what to learn, which roles use it, what companies expect and what gets you hired.

    What to learn in 2026

    Learn to brief a builder the way you would brief an engineer, to read enough code to know when it is wrong, and to ship with the security, data and testing basics in place. The sub-nodes order the three.

    Prompting a builder

    A builder - Lovable, Bolt, Replit, v0, Emergent, or an agent like Claude Code or Codex - does what it is told, so the skill is telling it well: the one job the product does, the data it holds, the screens and their states, the rules and the edge cases, one change at a time, with a test for each. Vague prompts burn credits and produce confident, wrong applications. The Stack Overflow 2025 survey's 52 percent productivity gain goes to the people who specify; the 45 percent debugging loss goes to the people who did not. The Startup roadmap's build stage is the practical version of this node.

    Reading what it wrote

    You do not need to write the code, but you need to read it well enough to catch the four common faults: a secret in the client, a database rule that lets anyone read anything, a missing error state, and a feature that silently does less than you asked. Learn the basics of the language the builder uses - almost always TypeScript and React - and ask the agent to explain any file you do not understand until you do. The Stack Overflow 2025 survey's 46 percent distrust is the right posture; GitHub's finding that most new developers start with an assistant means reading generated code is now the first programming skill.

    Shipping safely

    AI

    Shipping safely is a checklist: secrets in environment variables, authentication from a provider, row-level security on every table, HTTPS, a spending cap on every model and cloud account, backups restored once, a test for the one job, and a privacy policy for the data you hold. Builders generate insecure defaults often enough that the audit is part of the work. The Startup roadmap's Ship stage and the Claude Code roadmap's review habits are the detail; the rule is that generated code is a draft until a human has checked the parts that touch data, money and identity. The Stack Overflow 2025 survey's finding that 45 percent of developers lose time debugging AI-written code is the cost of skipping the check.

    Which roles use it

    Founders, product managers and operators use vibe coding to build what they used to wait for; developers use it carefully for speed. The sub-nodes name both groups and lay out the fresher and switcher routes.

    Founders and PMs

    Founders build the first version themselves now, product managers prototype features before engineering touches them, operators build the internal tools they used to request, and marketers build landing pages and automations; the Work Trend Index found 75 percent of knowledge workers using AI at work and Microsoft's 2025 index describes every employee becoming a manager of agents. For these roles vibe coding is leverage, and the skill that separates a useful prototype from a liability is the shipping checklist.

    Developers, carefully

    Professional developers use the same tools with more scepticism: the Stack Overflow 2025 survey found 72 percent saying vibe coding is not part of their professional work even as 84 percent use AI tools, which is the distinction between letting a model write unreviewed code and using an agent inside a review loop. For a developer the skill is the Claude Code roadmap's loop - specify, draft, check, own - and the judgement about which parts of a system may never be vibed: payments, authentication, data migrations, anything regulated.

    Fresher vs switcher

    A fresher who can build and ship a working product with these tools has something most graduates do not - but the hiring interview will test whether they understand what they shipped, and HackerRank's 2025 report says practical, explained work is now the standard. Learn the JavaScript basics alongside the building. A switcher from a non-technical role should build in their own domain, where they know what correct looks like. On this map freshers get the basics filled and the advanced stages outlined; experienced learners get the reverse.

    What companies expect

    Companies expect a working, safe result and an honest account of how it was built: what the tool generated, what you checked, what you changed and what you would not trust it with. The sub-nodes cover the bar, the interview and what gets verified.

    The hiring bar

    The bar for anyone shipping vibe-coded software is a working product with the checklist done and an honest account of its limits: what the tool built, what you verified, what you changed, what you would not let it touch, and what happens when it fails. The Work Trend Index's 71 percent of leaders who prefer AI-skilled candidates want the leverage; the Stack Overflow survey's 46 percent distrust is why they also want the judgement.

    What interviews test

    Expect to build something small live with a tool and explain the result - including the code - to be asked what you would check before letting users in, and to walk through a product you shipped with the tool and the problems you found in it. For developer roles expect the review loop examined; for product and founder conversations expect questions about scope, data and security. HackerRank's 2025 report says practical assessments are now the standard; this is one. The strongest answers include a bug the tool introduced and how you caught it.

    Proof they verify

    Reviewers open the product and the repository: real users or real data, the security checklist visibly done, a readme that states what was generated and what was checked, and a short account of the tool workflow beats any claim of speed. Pair it with a verified OneRoadmap certification in the language the builder used - the JavaScript certification is free and verifiable - so the reading skill is proved too.

    What gets you hired

    A shipped product people use, a repository you can explain, and the judgement to know the limits. The sub-nodes give the ninety-day plan, the projects that get read and the proof that counts.

    A 90-day plan

    Month one: one small product built with a builder from a half-page scope, shipped on a real domain, with the JavaScript basics learned alongside. Month two: the security and data checklist applied, tests for the one job, a second feature added through an agent with the diff read, and five real users onboarded. Month three: a write-up of what the tools built and what you fixed, the JavaScript certification, and either twenty targeted applications a week or - for founders - the Startup roadmap's first-users stage. GitHub's Octoverse 2025 found 80 percent of new developers using Copilot in their first week; the checklist is what separates a product from a liability.

    Projects that get read

    Projects that get read are shipped and honest: an internal tool a real team uses with the checklist done; a small product with sign-in, a database and payments built with a builder and audited; a prototype that became a feature with the engineering team's review recorded; a write-up of a generated bug and its fix. The Stack Overflow 2025 survey says most developers distrust AI output; a project that shows you checked it is the counter-evidence.

    Certification and proof

    Proof is a product in use plus the ability to explain it: a live link, a repository with the checklist visible, a verified certification in the language and a clear account of the workflow. With most new developers starting with an assistant in their first week, the ones who stand out are the ones who can show what they understood.

  2. 2. Understand what changed and what didn't.

    The New Loop

    Understand what changed and what didn't.

    Time: about 2-3 days. Topics: What vibe coding is · The tool landscape · Honest limits.

    What vibe coding is

    Optional on the Experienced track

    Outcome-first development: you describe, AI implements, you verify - judgement moves up the stack, it doesn't disappear.

    The tool landscape

    Optional on the Experienced track

    Agentic CLIs (Claude Code), AI editors (Cursor), app builders (v0, Bolt) - pick per project shape.

    Honest limits

    Optional on the Experienced track

    Where AI code fails: novel domains, security edges, large refactors - knowing when to slow down.

  3. 3. Prompts that produce products.

    Directing AI

    Prompts that produce products.

    Time: about 1 week. Topics: Describing outcomes · Iterating in small steps · Giving feedback that lands.

    Describing outcomes

    User stories, constraints and acceptance criteria as prompts - specificity in, quality out.

    Iterating in small steps

    One feature per ask, verify, commit - momentum without a haunted codebase.

    Giving feedback that lands

    Screenshots, error messages and 'expected vs got' - debugging as a conversation.

  4. 4. Trust nothing; verify everything cheaply.

    Verification Discipline

    Trust nothing; verify everything cheaply.

    Time: about 1 week. Topics: Reading AI code · Testing as the contract · Security & secrets hygiene.

    Reading AI code

    Skimming for architecture, auth, data handling and edge cases - review as your core skill.

    Testing as the contract

    Asking for tests first, running them always - green tests as the definition of done.

    Security & secrets hygiene

    Never paste secrets, review auth paths, dependency awareness - the vibe coder's non-negotiables.

  5. 5. From vibe to deployed product.

    Ship Something

    From vibe to deployed product.

    Time: about 1-2 weeks. Topics: Deploy & domain · Building taste · Just enough fundamentals.

    Build: Ship a micro-product. Take one small idea to a deployed URL with tests, a README and a real user trying it - in two weeks.

    Deploy & domain

    Optional on the Fresher track

    Vercel/Netlify, env vars and a custom domain - the last mile most demos never walk.

    Building taste

    Optional on the Fresher track

    Studying great products, copying interactions, sweating defaults - taste is the moat when code is cheap.

    Just enough fundamentals

    Optional on the Fresher track

    HTTP, git and reading errors - the floor of knowledge that keeps you unstuck and unscammed.

Prove it as you go

Reading is half of it. The free, scored AI Work Competency certification covers the ground this roadmap leads to, and the Full-Stack Engineer job simulation puts it to work on real tickets - evidence a recruiter can check. Mark topics done, learning or skipped as you go; your progress carries into the classic view.

Fresher or experienced?

Both tracks hold every topic. On the Fresher track the foundations are filled and the later stages are outlined - do them when a project needs them. On the Experienced track the foundations are outlined and the later stages are filled. The 2026 section at the top applies to both.

Prefer a list?

The classic view shows the same 4 stages as a sequential checklist with time estimates. Your marks are shared between the two views.

Frequently asked questions

What is vibe coding?

Describing what you want and letting an AI builder or agent write the code - Lovable, Bolt, Replit, v0, Emergent, Claude Code, Codex - then iterating in plain language. It is how a growing share of software starts in 2026 and how most non-developers now build. Done well it is leverage; done carelessly it ships insecure products.

Can I build a real product without knowing how to code?

Yes, and many founders do - the Startup roadmap assumes it. The limits are the parts that touch data, money and identity, where generated defaults are often insecure, and the moment the builder stalls on something it cannot see. Learning to read enough code to catch the four common faults is what makes the product safe to ship.

Do professional developers vibe code?

They use the same tools with more scepticism: the Stack Overflow 2025 survey found 84 percent using or planning to use AI tools while 72 percent said vibe coding is not part of their professional work - the distinction between unreviewed generated code and an agent inside a review loop. The Claude Code roadmap is the developer's version.

Which builder should I use?

One, not six. Lovable for a full application with a backend from chat, Bolt for a fast browser prototype, Replit for building and hosting in one place, v0 for interfaces on Next.js, Emergent for a whole app built and tested autonomously. Start from a half-page scope, build one job, share the link within a week.

What must I check before letting users in?

Secrets in environment variables, authentication from a provider, row-level security on every table, HTTPS, a spending cap on every model and cloud account, backups restored once, a test for the one job and a privacy policy for the data you hold. Builders generate insecure defaults often enough that the audit is part of the work.

How long does it take to ship something?

A first clickable prototype takes an hour; a product with sign-in, a database and payments that is safe to put in front of users takes weeks, most of it on the checklist and the reading rather than the generating. Nobody can promise a timeline. A product in use plus the ability to explain it is the evidence.

Will AI builders make developers unnecessary?

It made first drafts cheap and made reading, reviewing and securing them valuable. The Stack Overflow 2025 survey found 46 percent of developers distrusting AI output and 45 percent losing time to debugging it. People who can generate and then check are in demand; people who can only generate are producing liabilities.

How do I prove I can ship with these tools?

A product in use with the checklist visibly done, a repository you can explain, a readme that states what was generated and what you checked, a write-up of a generated bug and its fix, and OneRoadmap's free JavaScript certification so the reading skill is proved too.