How I AIThe beginner's guide to coding with Cursor | Lee Robinson (Head of AI education)
CHAPTERS
- 0:00 – 2:05
How Cursor helps you build better software: agents that can fix real issues
Lee previews a practical workflow: asking Cursor’s agent to fix lint errors end-to-end. The key idea is delegating outcomes ("fix lint") rather than step-by-step instructions, letting the agent read files, run commands, and verify results.
- •Cursor agents can read the repo, run terminal commands, and apply fixes
- •Outcome-driven prompting (GPS-style) vs. manual step-by-step instructions
- •Verification loop: run lint → change code → rerun lint
- •Sets the episode’s focus on making code less intimidating and more reliable
- 2:05 – 3:30
What Cursor is in the AI builder ecosystem (beginner to power user)
Claire and Lee define Cursor as an AI-native code editor that supports multiple frontier models and also ships custom models for coding assistance. They frame Cursor as a bridge tool that supports everyone from first-time coders to expert developers.
- •AI code editor with access to models from OpenAI/Anthropic/Google plus Cursor-trained models
- •Designed for a spectrum: beginners through power users
- •Cursor as a practical learning surface because you can see and inspect code
- •The goal: make building and maintaining software more accessible
- 3:30 – 5:29
Why looking at code matters: learning by reading, not just generating
Claire argues that an IDE is valuable even for non-engineers because code is readable and learnable. Lee empathizes with the overwhelm of file trees and extensions and explains that better abstractions (and AI) reduce that learning curve.
- •IDE visibility helps people parse and learn code structure
- •File trees and extensions are intimidating at first but become navigable
- •JavaScript ecosystem as a common beginner entry point
- •AI tools can lower friction without hiding fundamentals
- 5:29 – 8:03
Cursor’s three-panel interface and the autonomy slider
Lee breaks down the UI: files on the left, code/editor in the center, and the agent on the right. He explains different levels of AI assistance—from inline autocomplete to an agent that can author multi-file changes.
- •Left: project directory and files; Middle: focused editing; Right: agent panel
- •Autocomplete for local edits and imports vs. full agent workflows
- •“Autonomy slider” concept: choose how much the AI does
- •Agent can write or refactor entire files, not just snippets
- 8:03 – 11:45
Engineering guardrails that make AI coding safer: types, linters, formatters, tests
Lee explains that traditional software engineering practices make AI agents more effective because they create structured feedback. Claire translates the concepts for beginners, emphasizing how each tool prevents errors and helps the agent self-correct.
- •Typed languages (e.g., TypeScript) add strictness and editor feedback
- •Linters catch common mistakes and style issues early
- •Formatters standardize code appearance automatically
- •Tests validate behavior and give agents actionable failure output
- 11:45 – 15:51
Demo: asking the agent to fix lint errors (and learning from the diff)
Lee demonstrates a minimal prompt—"Fix the lint errors"—and shows the agent running the lint command, identifying issues (including unsafe `any` typing), applying fixes, and rerunning lint to confirm success. Claire highlights the educational value of reviewing diffs and learning commands like running lint manually.
- •Simple prompt triggers: run `bun run lint` → diagnose → patch → rerun
- •Agent replaces unsafe typing and applies formatting fixes
- •Verification is built into the workflow (rerun checks)
- •Diff review teaches beginners what changed and why
- 15:51 – 19:12
Parallelizing work: keep coding while the agent “cooks” in the background
Lee describes a productivity pattern: stay focused in the main editor while running separate agent tasks in parallel. This evolves AI from “code generator” to “pair programmer,” where you strategically decide when to take the wheel.
- •Run side tasks (new routes/features) while you work in the main file
- •Agent tasks can run unattended and be checked later
- •Progression: generation-first → collaborative pair programming
- •Build the skill of delegating well-scoped parallel tasks
- 19:12 – 20:33
Cursor setup: when and how to use rules + custom commands
Lee recommends adding rules when you see repeated model mistakes, turning recurring preferences into reusable guidance. He shows defining a custom “code review” command and explains how it can be refined over time for consistent checks.
- •Create a rule after 2–3 repeated “wrong” model behaviors
- •Rules codify preferences: writing style, tooling (e.g., package manager), conventions
- •Custom commands (e.g., “code review”) run consistent prompt routines
- •Commands can cover security review, cleanup, testing expectations, and more
- 20:33 – 23:35
Using @mentions for precise context: files, Git branches, commits, and more
Lee explains Cursor’s @menu as a structured way to pass the right context to the agent, including Git state. Claire notes this is often overlooked if you only rely on typeahead, and the two discuss how Git references map to “working changes” (branch) vs. a single snapshot (commit).
- •@menu supplies agent context: files, images, and Git references
- •Branch context = all working changes; commit = a specific saved change
- •Practical for code review prompts and targeted debugging
- •Helps prevent vague prompts by attaching the exact relevant artifacts
- 23:35 – 24:48
Model strategy: Auto selection vs. choosing reasoning models intentionally
Claire asks why Lee uses Auto model selection; Lee argues it’s best for beginners to avoid model overwhelm while still getting good speed/quality tradeoffs. As users mature, they can pick specialized models (e.g., reasoning modes) for complex tasks.
- •Auto selects models based on speed, quality, and availability
- •Beginners avoid the cognitive load of model choice
- •Advanced users can select reasoning models for harder problems
- •Learn model “quirks” and output styles through deliberate usage
- 24:48 – 29:05
Micro-slicing agent chats: managing context bloat and improving success rates
They discuss why long chats degrade quality as context fills up, and Lee recommends starting new chats per discrete feature. Claire adds a tactic: isolate one-off questions into separate chats to avoid derailing the main task’s context.
- •Context % grows over time; quality can degrade near high utilization
- •Cursor can summarize at 100%, but it’s better to avoid huge threads
- •Start new chats for discrete features or initiatives
- •Separate “side questions” to keep the main agent thread on track
- 29:05 – 36:11
Beyond code: using AI as a writing linter/formatter with banned words and patterns
Lee shares a writing workflow using the ChatGPT desktop app with a large prompt that encodes voice, tone, banned words, and “LLM tells.” Claire connects it back to coding: this is essentially linting and formatting for prose, reducing generic marketing language and repetitive AI phrasing.
- •Mega writing prompt: tone rules + banned words/phrases + examples
- •“LLM patterns” list to reduce obvious AI-generated cadence
- •Process: rough thoughts → first draft → AI as reviewer/editor
- •Use AI to remove generic marketing language and improve specificity
- 36:11 – 42:46
Lightning round: who should use vibe coding vs. Cursor, and how to start learning
Lee maps tools to personas: vibe-coding tools for first exposure, Cursor when you’re ready to understand and maintain real code. He recommends starting with JavaScript or Python, and encourages learning by reading code and asking what unfamiliar syntax means.
- •Vibe coding tools spark interest without requiring code literacy initially
- •To maintain real products, you eventually need to understand the code
- •Recommended starter languages: JavaScript (browser feedback) and Python (readable)
- •Learning path: notice syntax → ask questions → build understanding iteratively
- 42:46 – 45:27
When the model goes wrong: calm re-prompts, clearer intent, and closing thoughts
Lee admits frustration is normal, but emphasizes that vague negative feedback doesn’t help—restate what you actually wanted with specific constraints. They wrap with where to find Lee and upcoming educational content from Cursor.
- •Emotional “fix it” prompts fail; specify what’s wrong and desired behavior
- •Add missing context explicitly instead of assuming mind-reading
- •Treat the agent like a colleague: clear, calm requirements
- •Lee’s links and upcoming free AI foundations course
