Contents

What's Inside

Chapter One

What Vibe Coding Is — and What It Can Build

Somewhere between traditional programming, no-code tools and copy-pasting from forums sits a new way of making software: you describe what you want, AI writes the how, and you direct, review and refine. That's vibe coding, and this chapter sets it up honestly — capabilities, limitations, and your very first prompt.

The spectrum, and where you sit

Place the paradigms on a spectrum from fully human-written code to fully AI-driven, and vibe coding lands in the sweet spot: more capable than no-code's templates, more accessible than programming, more rigorous than copy-paste-and-pray. The defining shift is the architect mindset from the course's role-play simulator: a traditional developer thinks in steps and syntax; a vibe coder thinks in outcomes and descriptions. You're not learning to write code — you're learning to be understood by something that writes it brilliantly and literally.

What it can actually build

The course's gallery of twenty real projects calibrates ambition nicely: fifteen-minute landing pages, calculators and trackers, dashboards, quizzes, booking tools, full multi-page apps with data and accounts — each with the actual prompts revealed. The range is genuinely wide; the pattern is that well-defined beats novel: AI coding tools are remarkably capable for problems the world has solved before (which is most business software) and wobblier at the genuinely unprecedented.

Honest expectations

The myth-buster quiz earns its place early. The truths worth carrying: AI-generated code works impressively often and contains errors confidently; "no programming experience required" is true, while "no thinking required" is a lie; your first prompt will not produce your final app (iteration is the method, not the failure mode); and AI will occasionally invent functions and APIs that don't exist — Chapter Nine trains you to catch them. Calibrated expectations are the difference between a builder who persists and a tourist who quits at the first error message.

Your first vibe

So let's write the first prompt properly. The First Prompt Builder structures it: what the app does (one to three sentences), who it's for, the key features, and how it should look. The clarity scorer rates the result before any AI sees it — because the single best predictor of output quality is input clarity, a theme this book will hammer until it's reflex.

Chapter Two · Tool facts checked June 2026

Your Toolkit: ChatGPT, AI Studio, Bolt & Beyond

Three tools carry this course, each with a distinct personality, and choosing well at the start saves weeks of friction. Here's the honest tour.

The big three

ChatGPT is the conversationalist: code generation, concept explanation and debugging in one chat window. It's not just a code generator — it's a thinking partner that explains why, which makes it the best teacher of the three (Chapter Four is its deep dive). Google AI Studio is the instant builder: Build mode collapses the distance from prompt to live preview to nearly nothing — describe, watch it appear, refine in real time (Chapter Five). Bolt is the full-stack workshop: a real code editor, file structure, databases, authentication and one-click deployment — where your projects grow up (Chapter Six).

Choosing without agonising

The comparison matrix rates all three across fifteen criteria, and the recommendation engine personalises it from three questions. But here's the secret that deflates the agonising: you'll end up using all three — ChatGPT to think and debug, AI Studio to prototype, Bolt to ship. The question isn't which is best; it's which to start with, and the answer is whichever matches this week's project. Beyond the big three, the landscape explorer covers the wider field (Cursor, Lovable, Replit and friends) — star a couple for later, then stop browsing and start building. Tool shopping is the procrastination that feels like progress.

Chapter Three

Prompt Engineering for Builders

In vibe coding, the prompt is the source code. This chapter teaches the anatomy, the difference between weak and strong, and the iterative method that turns first drafts into finished apps.

The five components

Every great build prompt contains five parts, colour-coded in the course's Prompt Dissector: What (the app's purpose and features), Who (the users and their context), How (behaviour — what happens when buttons are pressed), Look (visual style, layout, mood), and Constraints (single file? mobile-first? no login?). Toggle any component off in the dissector and watch the quality score sag — each one removes a guess the AI would otherwise make, and AI guesses are where apps go strange.

Weak vs strong

The before/after lab makes the lesson visceral: the same intent, expressed weakly versus strongly, produces dramatically different apps. The difference is rarely length — it's specificity where it matters:

Iterate like a professional

Nobody — human or AI — builds it right first time, and the course's refinement simulator teaches the professional rhythm: change one thing per iteration. "Make the header sticky." "Add a filter for completed tasks." "Soften the colour palette." Each small prompt is checkable; the bundle-everything mega-prompt is how you lose track of what broke what. Refinement isn't failure — it's literally how all software is made.

Roles, system prompts, and the library

Two force multipliers finish the kit. Role assignment changes everything downstream: "act as a senior front-end developer who prioritises accessibility" produces different code than no role at all — the role workshop shows the same request transformed by five personas. And the prompt library hands you 30+ tested templates across building, debugging, learning, design and deployment. Bookmark ruthlessly; professionals reuse.

Chapter Four · Tool facts checked June 2026

Building with ChatGPT: Generate, Learn, Debug

ChatGPT deserves its own chapter because it plays three roles at once: code generator, patient tutor, and debugging partner. Master the trio and you have a complete development environment that happens to talk.

Generation workflows

Structure beats improvisation: the course's workflow guides cover the common builds — page layouts, forms, data processing scripts, interactive components — each with prompt templates and a quality-check rubric to run before accepting the output. The professional habit hiding in there: don't just take the code, check the code against criteria. Does it handle empty input? Does it work on mobile? You don't need to read code to check behaviour.

The tutor you always wanted

Here's the under-used superpower: ChatGPT explains anything at your level, with your analogies. The course's best trick deserves wide adoption: ask for explanations in a domain you already know — "explain APIs like I'm a chef" (recipes in, dishes out, the kitchen hidden), "explain databases like I'm a librarian". You're not trying to become a programmer, but each concept you understand makes your prompts sharper and your debugging calmer. The concept explorer covers the eight ideas worth knowing.

The debugging workflow

Things break; the workflow is copy-paste-fix. The quality of your debugging prompt determines the quality of the fix — "it's broken" begets "have you tried turning it off and on", whereas:

The error simulation lab drills eight common scenarios. And know the workarounds for ChatGPT's characteristic failures (the limitation explorer covers all four): hallucinated APIs (ask "does this library actually exist?"), outdated patterns (specify versions), token limits (build in sections), and inconsistency (one chat per project, context pasted fresh). Finally, keep a prompt log — what you asked, what worked, what didn't. Professional AI practitioners document their process; it's also how you discover you've improved.

Chapter Five · Tool facts checked June 2026

Google AI Studio: Build Mode to Cloud Run

If vibe coding has a magic-trick moment, it's AI Studio's Build mode: type a description, watch a working app appear in the live preview, and refine it by talking. This chapter takes you from first build to a live URL on Google's infrastructure.

Build mode fundamentals

The workflow is gloriously short: describe your app, watch Build mode generate it, see it running in the preview pane, refine. The guided tutorial walks every click from blank screen to working app. Two habits from the start: begin from templates when one is close (they're starting points, not finished products — the workshop shows how small prompt changes turn one template into completely different apps), and treat the preview as your conversation partner — look, react, refine.

Refinement and the multimodal tricks

The refinement lab drills ten techniques — colours, features, layout, behaviour, data — and the principle from the course holds: refinement isn't about fixing mistakes; it's how the work gets good. Then the party tricks that are actually workflow: multimodal input — draw annotations on the preview, use voice, click an element and say what to change — and system instructions that lock in a design persona ("all apps: warm minimalism, rounded corners, mobile-first") so every build in a project family matches without restating the style each time.

Deployment to Cloud Run

The graduation moment: the deployment guide's seven steps take your app from preview to a live URL on Google Cloud Run — shareable, on real infrastructure, with cost estimates that for personal projects round to approximately nothing. There is a particular feeling when your app loads on someone else's phone; this chapter's job is to get you to it.

Chapter Six · Tool facts checked June 2026

Bolt: Full-Stack Without the Fear

Sooner or later your apps want to remember things, know who their users are, and talk to other services. That's full-stack territory, and Bolt makes it navigable without a computer science degree — provided you learn to read the map.

Quickstart and the interface

The quickstart lab takes you from account to deployed app in one sitting: prompt in the chat panel, code appears in the editor, app runs in the preview. Bolt's power comes from that trinity working together — you converse on the left, and real, inspectable code accumulates in the middle. Which brings us to the gentle superpower this chapter teaches…

Code literacy: reading, not writing

You don't need to write code, but learning to read what AI built changes everything. The file tree explorer walks a typical Bolt project — components (the visible pieces), styles (the look), utilities (the helpers) — with annotations in plain English. Ten minutes of reading literacy pays off every time something breaks: you can point at the problem file in your next prompt, and precision in, precision out. It's the difference between "my app is broken" and "the error is in TaskList, around the date formatting".

Backends, in human terms

The concepts behind the scary words, via the visualiser: a database is memory that survives the page refresh; authentication is the bouncer checking who's who; APIs are how your app orders things from other services. You don't need to master the internals — you need to prompt for them clearly: "add user accounts with email sign-in; each user sees only their own tasks". Bolt and its integrations (databases, auth providers, payments) handle the plumbing; the integration prompt builder gives you the words. Also worth a visit: the model comparison lab — different AI models inside Bolt produce different code styles and speeds, and there's no single best, only best-for-this-task (where have you heard that before?).

Publishing properly

The publishing workshop finishes the job: deploy to bolt.host, configure the URL, test on an actual phone, and run the post-launch checklist before sharing widely. Publishing isn't the end of building — it's the moment your app meets reality, and reality files excellent bug reports.

Chapter Seven

The Development Loop: Iterate, Debug, Version, Test

Tools change; the loop is forever. This chapter installs the four professional habits that turn enthusiastic dabbling into reliable building — the same habits, it turns out, that professional developers run, just translated into prompts.

Idea → Prompt → Review → Refine

The master rhythm, drilled in the loop simulator across three project scenarios with decision points at every stage. The simulator's quiet lesson: early decisions cascade — a fuzzy idea makes a fuzzy prompt makes a baffling review, and no amount of refinement rescues a project that skipped its thinking. Spend the extra two minutes at the idea stage; they're the cheapest minutes in the loop.

Three ways to debug

When errors strike, you have three strategies, and the debug workshop (twelve scenarios) builds your intuition for which fits when: self-diagnosis (read the error, check the obvious — fastest when it works, and Chapter Six's reading literacy makes it work more often), AI-assisted debugging (the Chapter Four prompt — the workhorse), and start-from-scratch (regenerate the component cleanly — underrated when an error spiral has poisoned the context; sometimes the bravest fix is a fresh start with a better prompt).

Version control, demystified

Version control is save points for your project — that's it, that's the concept. The visual Git timeline teaches it without jargon: commit (save a snapshot, with a note saying what changed), compare versions, and roll back when an experiment goes wrong. For a vibe coder the habit is simple: save a snapshot before every big change. It converts "I broke everything and can't get back" — the most demoralising moment in building — into "ah well, roll back, try again". Courage, purchased for one click.

Testing: break it before they do

The course's framing is exactly right: testing isn't proving your app works — it's trying to break it before your users do. The test plan builder generates a checklist for your app type across five categories: functionality, edge cases (empty inputs, absurd inputs, double-clicks), mobile, speed, and the confused-user test. Run it before anyone else sees the app; every bug you find is one a user doesn't.

Chapter Eight

The Capstone: Proposal to Presentation

Time to build something that matters to you, start to finish, with the structure that separates a finished project from an abandoned tab. Four stages: propose, track, test with humans, present.

The proposal

The proposal workshop structures your capstone: goals, audience, features, tools, timeline — six sections, scored against the assessment rubric before you build. The insight the course offers here is the one most builders learn expensively: a strong proposal is your defence against scope creep. Decide what the app is — and, harder, what it isn't — while changes are free. The feature you cut at the proposal stage costs nothing; the one you cut in week three costs a week.

Milestones and momentum

Five milestones carry you from proposal to presentation, tracked in the dashboard with checklists and evidence at each stage. The structure isn't bureaucracy — it's momentum engineering: each completed milestone is a visible step, and visible steps are what keep solo projects alive past the exciting first weekend.

User testing: the humbling, useful bit

Then the bravest step: real people using your app while you watch and don't help. The testing toolkit structures it — test checklists, feedback collection, fix prioritisation — and documents the prompt-refine loop for each bug found. Expect the universal discovery: users do things you never imagined, immediately. That's not failure; that's the most valuable QA you'll ever get for the price of a coffee.

Present the thinking

Finally, the presentation builder structures your five-minute showcase: demo script, prompt showcase (the journey from first prompt to final app — for a vibe coder, the prompts are the craft, so show them), lessons learned, and reflection. The portfolio page generator links it all to your deployed app. A finished, deployed, documented project puts you in a small and persuasive minority — of builders generally, not just AI-assisted ones.

Chapter Nine

Pitfalls, Hallucinations & Recovery

Every experienced vibe coder has fallen into every hole in this chapter. The difference experience makes isn't avoiding them — it's climbing out in minutes instead of evenings. Here's the guided tour of the holes.

The eight classic pitfalls

The pitfall simulator lets you experience each mistake safely and practise the recovery: ambiguous prompts (the AI builds something, confidently — recovery: stop, rewrite with the five components), error spirals (each fix breaks something new as the context degrades — recovery: fresh chat, clean prompt, current code pasted in), token exhaustion (the AI forgets your project mid-build — recovery: build in sections, summarise progress between chats), scope creep ("just one more feature" — recovery: your Chapter Eight proposal, re-read), plus the kitchen-sink prompt, the untested deploy, and friends. Read them now, cheaply.

Hallucinated code: spotting the confident fake

AI's signature failure deserves special drilling: code that looks immaculate and uses functions, libraries or APIs that don't exist. The detector lab trains your eye on ten snippets — some real, some fabricated — and the verification habits transfer straight to your builds: if the AI cites a library, ask "does this actually exist?"; if a function looks suspiciously perfect for your exact need, be suspicious; and when in doubt, the error message will tell you ("X is not defined" is the hallmark of a hallucination meeting reality). The standing rule from every book in this series, in builder's dialect: working-looking is not working — run it.

Recovery as a skill

The meta-lesson the simulator teaches: recovery is a skill, separately learnable from building. The general algorithm: stop prompting in the broken context, roll back to your last good snapshot (Chapter Seven's habit, paying off), diagnose calmly with full information, and re-approach with a better prompt. Panic-prompting into a degraded chat is the one move that never works — every other path leads home.

Chapter Ten

Collaboration, Ethics & Next Steps

The final chapter looks outward: building with other people, building responsibly, and where the road leads from here.

Collaboration: share the prompts, not just the product

Vibe coding in a team has its own etiquette, drilled in the collaboration workshop: share prompts so others can reproduce and extend your work; compare outputs (two people, same brief, different prompts — the differences are the masterclass); and peer-review AI-generated work with the same rubrics you use on your own. The artefact that makes you valuable in any team: the process document — your prompts, iterations and decisions, showing the thinking rather than just the output. In an AI-assisted world, the thinking is precisely what proves the work is yours.

Ethics and AI literacy

Four commitments make a responsible vibe coder, assessed honestly in the self-assessment: attribution (be honest about AI's role — in portfolios, at work, in class; the disclosure habit from every book in this series), bias awareness (AI-generated apps inherit assumptions — about names, defaults, who the "normal" user is; review with other users in mind), verification (never ship what you haven't tested — by now a reflex, keep it one), and over-reliance prevention (use AI to extend your thinking, not replace it; if you can't explain what your app does and why, slow down and ask the tutor from Chapter Four).

Where this road goes

And so: you came in unable to build software, and you leave with deployed apps, a capstone, a portfolio page and — more durable than any of them — the loop, the prompt craft, and the recovery skills. Where next is genuinely your choice: deeper into full-stack territory (Bolt and its peers reward ambition), sideways into agents and automation (your apps can start doing things on their own — the next course over), or simply onward, building the tools your life and work actually need, which is the quietly radical option. The barrier between "person with an idea" and "person with an app" has fallen in your lifetime — this year, possibly this month. You're on the good side of it now. Build accordingly, and do send me what you make.