Video summary

Cursor Crash Course: Vibe Coding on a Large Codebase

Main summary

Key takeaways

Technology

Summary of the subtitles (Cursor Crash Course: Vibe Coding on a Large Codebase)

What the tutorial claims to teach

  • How to write code “10x faster” using Cursor 2.0.
  • How to combine Cursor tool usage with systematic “vibe coding” principles that can generalize to other AI coding tools.
  • How to demonstrate these ideas in both: 1) building a small full-stack app (frontend + backend + database), and 2) working with a more enterprise-grade e-commerce codebase, including bug fixes and feature additions.

Part 1: Build a gardening e-commerce website with Cursor

Setup / configuration

  • Install Cursor from cursor.com/d.
  • Cursor UI can switch between:
    • Agentic view (default)
    • Editor view (more like a traditional IDE / VS Code)
  • Model selection:
    • Free tier uses auto model routing.
    • Paid tier ($20/month mentioned) can use Opus 4.5 (Anthropic) for coding.

Using voice + plan/agent workflow

  • Uses Whisperflow (free audio-to-Cursor integration) to speak requirements.
  • Workflow distinction:
    • Plan mode: collects requirements and produces architecture + a to-do list, but doesn’t write code.
    • Agent mode: implements tasks and writes code, automatically switching when you press Build.

Architecture generated from the prompt

  • Example app spec includes:
    • Frontend: Next.js
    • Backend: FastAPI
    • Database: SQLite
    • Mentions state management via React Context
  • Cursor produces:
    • architecture overview
    • database schema (tables like categories/products/orders/items—described as multiple tables)
    • code files such as models.py, requirements.txt, and more.

Iterative implementation via “to-dos” (Jira-like)

  • Cursor breaks work into numbered to-dos (e.g., “2 out of 10”).
  • The author compares this to a Jira board, where AI marks tasks “done” sequentially.

Running/testing and viewing results

  • Cursor starts servers on its own after coding.
  • If errors occur, it retries on Run.
  • The site is tested across pages (described like “a developer would test it”).
  • Example UI feature test:
    • Adds a “Contact Us” button to the navbar by selecting the element in the editor/UI.
  • Guidance also recommends:
    • starting a new chat when making bug fixes/features to avoid stale context.

Review/accept loop

  • Cursor offers:
    • Review (code/text output review)
    • Keep / accept changes
  • The tutorial emphasizes:
    • even if the AI implements successfully, the developer must review outputs and run/verify functionality.

Limitation noted

  • Free subscription may have quota/token limits; recommends building simpler features there.
  • Output quality depends on the coding model.

Part 2: Enterprise-grade production app (e-commerce like Amazon/Myntra)

Repository + setup approach

  • Uses a production-grade repo with:
    • backend + frontend
    • Docker option
    • README-driven setup
  • Demonstrates terminal usage inside Cursor (multiple terminals: backend and frontend).
  • Environment configuration:
    • Copy .env.example → .env and .env.local for frontend.
    • Backend uses email sending for buyer/seller notifications.
    • Uses Google App Passwords (includes obtaining an app password and removing spaces).

Application capabilities demonstrated

Seller and buyer account flows

  • Creates separate seller + buyer accounts using the same email setup.

Seller can upload products

  • Supports:
    • single upload
    • bulk CSV upload
  • Example says “10 products uploaded” and they appear on the storefront.

Bug fix via screenshot + context

  • Example bug:
    • cart badge count shows wrong quantity after adding multiple items.
  • Fix process:
    • take a screenshot of the UI area (badge mismatch)
    • describe the bug: “badge shows wrong number of items in my cart”
    • Cursor proposes code changes; even after a quota limit overrun, fixes are still applied
  • After acceptance/review, the badge correctly shows the total item count.

Feature addition: Wishlist

  • Adds wishlist by selecting a UI element and instructing:
    • “add a button… add to wish list… only one wishlist per user”
  • Cursor updates multiple files (noted as ~10 files changed).
  • Post-implementation demo:
    • items added to wishlist properly
    • wishlist items can be added back to cart

Structured logging tutorial (coding principles on a large codebase)

  • Demonstrates structured logging as a repetitive refactor pattern:
    • first add logging to card service
  • Review/commit model:
    • AI generates changes; user accepts via review
  • Scaling the change to other modules: 1) Refer to prior git commit IDs to apply a “similar change” elsewhere (e.g., email service). 2) Better method: create a Cursor “command” driven by a markdown instruction file. - Then run /add structured logging for any service.
  • Emphasizes team reuse:
    • commands/skill instructions can live in the Cursor repo, be committed to GitHub, and reused by others for standardized changes.

Cursor “Commands” vs “Rules” (governance patterns)

Commands

  • Precise, step-by-step action instructions (like GPS directions).
  • Implemented via:
    • slash commands (e.g., / add structured logging)
    • or via chat prompts
  • Backed by markdown instruction files.

Rules

  • Broader always-on guidelines (traffic-rule style).
  • Loaded automatically while Cursor writes code.
  • Examples of guideline categories:
    • API endpoint patterns
    • type safety rules (e.g., response model usage)
    • async/avoid sync calls
    • database query style (use select)
    • service layer conventions
  • Rules can target file patterns (wildcards/globs) and are organized into project/user/team scope.

Documentation + MCP integration for up-to-date APIs

  • Cursor can reference official documentation inside the editor (example: FastAPI docs).
  • Warns that AI may use outdated docs versions.
  • Introduces MCP server “context7” to access latest documentation indexing.
  • Shows how to add an API key in Cursor settings and configure Context7 usage.
  • Can enforce in rules: “always use context7 for API documentation.”

“Prompt anatomy” and “AI-first coding” philosophy

Orchestrator mindset

  • Human role = orchestrator:
    • provide intent + context + constraints + legacy conventions + architecture requirements
    • validate AI output
    • run code and review changes
    • iterate

Prompt layers: Rules + Commands + Context

  • Rules: persistent governance guidelines
  • Commands: immediate actionable steps (refactoring, logging, etc.)
  • Context: screenshots, traces/logs, selected folders, terminal output, documentation references

Validation/testing emphasis

  • AI can generate plausible code, but the developer must:
    • review code/text
    • run and verify behavior
    • add/upgrade automated tests (unit/integration/others)
    • potentially ask AI to help write test cases

Risk and mitigation

  • Without enough context, LLM output may be syntactically correct but architecturally invalid or production-breaking.
  • Over-reliance without review can make developers “dumb”; the tutorial suggests balancing AI use with an “AI detox day” (write some code by hand periodically).

Main speakers/sources (as inferred from the subtitles)

  • Primary speaker: the video creator/instructor (unnamed narrator demonstrating Cursor usage and coding workflow)
  • Sponsored segment source: Ultralytics YOLO (promo for “YOLO 26”)
  • Referenced individuals/authorities (not shown speaking, but cited):
    • Linus Torvalds (quoted as validating AI-first development—anti-gravity referenced)
    • Boris Chenny (described as a main person behind Claude/Claude Code)
    • A “staff engineer at a fintech company” mentioned as an anecdotal source

Original video