How I Taught Myself to Vibe Code: A Free Bootcamp

On Learning

Deep Work Hours

Aim for as much time as you can daily.

Baseline: 2 hours of focused, distraction-free coding - no multitasking, no half-attention.

1. Read actively, not passively
   • Ask yourself:
     1. "What problem is this solving?"
     2. "Can I explain this in my own words?"
     3. "How would I code this right now?"
   • Capture notes or tweet-sized summaries after each paragraph.
2. Break into chunks
   • Don't grind through 20 pages straight. Take one concept at a time.
   • After 2–3 pages, stop → implement a tiny example in your editor.
3. Set a clear goal before opening the editor
   • Not: "I'll finish chapter 3."
   • Better: "I want to understand how FastAPI depends on Pydantic models."
   • This primes your brain to hunt for answers instead of drifting.

"He reads like a hawk sliding on the wind over a marsh, alert for what he could use."

— Robert Richardson on Ralph Waldo Emerson

---

The Roadmap: Six Phases to Vibe Mastery

Phase 0: Python Foundations

If you're completely new to Python, start here.

Phase 1: Tech Stack Mastery

Turn off autocomplete and coding AI (you can still ask AI questions).

This phase is about building your own reps.

Before you start vibecoding, you need a solid grasp of the tech stack you’ll be using.

Use these references only when stuck - ask AI to explain or show examples, but always type the code yourself.

Resources:

FastAPI Docs

HTMX Docs

SQLite Tutorial

Estimated 2 weeks

Week 1 — Core Muscles

• Day 1: Build a Basic CRUD API

  Create REST endpoints for items: POST and GET for /items, plus GET, PATCH, and DELETE for /items/{id}. Use SQLite with sqlite3.Row for database operations.

  ✅ Success criteria: All HTTP requests work end-to-end. Include created_at timestamps and X-Total-Count headers.

• Day 2: Add Interactive Forms

  Render the /items page as HTML using Jinja2 templates. Use HTMX to handle form submissions that post to /items and dynamically update the list.

  ✅ Success criteria: You can add new items without refreshing the page.

• Day 3: Implement Concurrent HTTP Requests

  Build a GET /probe?url=...&n=10 endpoint that uses httpx.AsyncClient to fetch the same URL multiple times concurrently. Use asyncio.gather with Semaphore(5) to limit concurrent requests.

  ✅ Success criteria: 10 requests complete in about 1 second. Include proper timeout handling and error counting.

• Day 4: Handle Background Processing

  Create a POST /import endpoint that accepts CSV files, saves them, then processes the rows using FastAPI's BackgroundTasks.

  ✅ Success criteria: The API responds immediately while processing happens in the background. A /imports/{id}/status endpoint shows processing progress.

• Day 5: Add Simple Authentication

  Implement cookie-based session authentication. The /login endpoint sets a signed cookie, and a get_current_user dependency protects the /me endpoint.

  ✅ Success criteria: Accessing /me returns 401 without a valid cookie and 200 with one.

• Day 6: Integrate Test Payments

  Build a POST /checkout endpoint that creates a Stripe Checkout Session using test API keys. Include success and cancel redirect pages.

  ✅ Success criteria: You can navigate to Stripe's test payment page and return to your success page.

• Day 7: Deploy with Monitoring

  Deploy your application to Fly.io or a budget VPS. Add middleware for request timing and X-Request-ID headers for tracking.

  ✅ Success criteria: Your deployed app logs HTTP method, path, status code, response time, and request ID for every request.

---

Week 2: SaaS Bits

• Day 8: Search & Filters

  Implement /items?search=&limit=&offset=&sort=-created_at with safe SQL and indexes.

  ✅ Success criteria: Deterministic order and correct count under load (hey -n 100 -c 20).

• Day 9: File Pipeline

  Accept image upload → store in /files → generate thumbnail in a process (via ProcessPoolExecutor).

  ✅ Success criteria: /thumbs/{name} returns the file without blocking the event loop.

• Day 10: Webhooks

  Create Stripe webhook endpoint that verifies signature; on event, mark user.plan = 'pro'.

  ✅ Success criteria: stripe cli triggers update locally.

• Day 11: Scheduler

  Add a simple scheduler: app startup creates asyncio.create_task(ticker()) or run separate cron.py.

  ✅ Success criteria: "Daily digest" row is visible at /digests/latest.

• Day 12: Multi-Tenant & Rate Limiting

  Add org_id to tables; queries scoped to current org. Add per-IP rate limit (in-memory or Redis).

  ✅ Success criteria: Tenant A can't see B's data; exceeding rate returns 429 with Retry-After.

• Day 13: Tests That Matter

  Use pytest with one fast happy-path and one 422 case. Mock HTTP with respx.

  ✅ Success criteria: pytest -q runs in under 3 seconds; CI-ready.

• Day 14: "Sell Something" Day

  Add /pricing, /checkout, success email (console), and tiny "Why buy" blurb.

  ✅ Success criteria: Someone can become "pro" end-to-end on your deployed URL.

Phase 2: Debugging Mastery

It's amazing that carbon-based life can reason, make music, and write code. But it's not yet the all-powerful AI from The Metamorphosis of Prime Intellect.

For now, we still have to read what it writes - and fix its mistakes.

Learning to debug effectively is what separates real developers from tutorial followers. When your app breaks (and it will), you need to know how to find and fix the problem fast.

Resources: Software Debugging

Estimated: 12 hours

---

Phase 3: Prompt Engineering and Vibe Coding

From this point on, it’s important to dedicate time to coding without AI.

What worked for me was splitting tasks: I let the AI handle most of the tickets, and I kept a portion for myself.

Resources:

Best Practices for Prompting Engineering

The Ultimate Guide to Vibe Coding

Estimated ~1 hour (intro)

---

Phase 4: Pre-Production (Plan Before You Code)

The biggest waste in coding is writing 500 lines for the wrong thing. Pre-production turns an idea into a plan so that every line of code matters.

1. Define the Problem

Write 1–2 sentences: Who has this problem? Why does it matter? If you can’t answer, you’re not ready to build.

2. Choose Core Features

Pick 1–3 features that directly solve the problem. Everything else is noise until users touch it.

3. Map the Flow

Picture your app as a scene: user enters → takes an action → gets a result.

Sketch it on paper or in Notion — no fancy tools needed.

4. Write the “Script” (Light PRD)

• Title: What the app is.
• Audience: Who it’s for.
• Problem: Why it exists.
• Features: Only the essentials.
• Success Metric: What does “working” mean?

Mindset: Pre-production isn’t bureaucracy — it’s clarity. One page of direction beats 10,000 wasted lines of code.

Resources:

PRD for Cursor

✍️ Task: Write the PRD for your startup (we’ll need it later).

Estimated 1 day

Phase 5: Production (Build & Ship)

You’ve got your script (PRD). Now it’s time to build.

Rule: Don’t build everything at once — code in small, testable scenes.

1. Start Small

Pick the simplest working version of your app.

Example (job board):

• Add a job
• View a job

That’s it. Login, payments, dashboards come later.

Reuse your FastAPI + HTMX drills (CRUD, forms, async, background tasks) inside the real app.

Watch: https://www.youtube.com/watch?v=BJjsfNO5JTo

2. Tight Feedback Loop

• Run the app early, even if it’s broken.
• Test each endpoint with httpie or your browser.
• Don’t move on until the feature works.

Mindset

Production is messy. Don’t chase perfect code — chase something real running on your screen.

Every working feature is another rep. Keep track of what works, what doesn’t, and curate your best prompts.

Deliverable

By the end of this phase you should have at least one shippable micro-startup.

Estimated: 2–3 weeks (1–2 hours/day)

---

Phase 6: Post-Production (Deployment & Distribution)

Running on your laptop isn’t enough. Post-production means putting it online and getting it in front of real people.

1. Deploy It

Choose your path:

• Beginner-friendly: Render, Fly.io, or Railway → push your code and it's live.

• Bootcamp-level: Deploy to your own VPS with Uvicorn + Nginx + systemd.

  • Resources:

    • Challenge: Linux Upskill Challenge (20 days) → go from zero to junior sysadmin.

Use the docs, and let AI guide you through setup when you get stuck.

2. Distribute It

Don’t just deploy — share it:

• Post a demo link on Twitter, Reddit, or Indie Hackers.
• Ask 2–3 friends for feedback.
• Keep a simple landing page (one sentence + sign-up or contact).

Mindset

Deployment is proof of work. Distribution is proof of value.

Get in the habit of showing your work early - feedback beats perfection.