How I AIThe beginner's guide to coding with Cursor | Lee Robinson (Head of AI education)
CHAPTERS
Why Cursor matters: making coding less intimidating (with Lee Robinson)
Claire introduces Lee Robinson and frames the episode around helping less-technical builders learn to ship software using Cursor. The key theme is that seeing and reading code—rather than hiding it—can be a powerful path to learning.
- •Cursor positioned as approachable for beginners but useful for advanced engineers
- •Episode goal: reduce intimidation and teach foundational software concepts through demos
- •Code literacy as a learnable skill by reading existing code
- •Promise of practical workflows plus configuration/pro tips
What Cursor is: an AI code editor with multiple models and built-in “skills”
Lee explains Cursor’s role in the AI-builder tool ecosystem: a code editor that integrates frontier models while also using custom models for coding-specific actions. The product spans beginner-friendly assistance through power-user automation.
- •Connects to models from OpenAI/Anthropic/Google plus Cursor’s own models
- •Custom models help with actions like predicting next edits and applying changes
- •Designed for a spectrum: beginners to professional developers
- •Goal: a “universe” of tools for coding with AI across workflows
Navigating Cursor’s three-panel IDE: files, code, and the autonomy slider
The conversation breaks down Cursor’s UI into a simple mental model: file tree on the left, active code in the middle, and the agent/chat on the right. Lee describes increasing autonomy from autocomplete to full agent-driven code changes.
- •Left panel: project directory and file structure (often overwhelming at first)
- •Middle panel: inspect/edit a specific file and review changes
- •Right panel: agent for higher-autonomy tasks across the codebase
- •Autocomplete as the lowest-friction AI assist; agent can write entire files
From vibe coding to learning by reading: how beginners can get started with a codebase
Claire suggests practical on-ramps for beginners: scaffold with a vibe-coding tool, download the code, and open it in Cursor to learn. Cursor’s diff view and ability to explain code supports a human-in-the-loop learning loop.
- •Simple entry path: generate prototype elsewhere, then open/download into Cursor
- •Reading code is how many engineers learned—Cursor keeps code visible
- •Diffs (red/green) help beginners understand what changed and why
- •Cursor can explain unfamiliar syntax and project structure on demand
Quality guardrails that help both humans and agents: types, linters, formatters, tests
Lee argues that classic software engineering guardrails make AI coding more reliable. Typed languages, linting, formatting, and tests provide fast feedback loops that the agent can use to self-correct and verify fixes.
- •Typed languages (e.g., TypeScript) add strictness and better editor/agent feedback
- •Linters catch common mistakes and enforce conventions
- •Formatters remove style debates and keep code consistent automatically
- •Tests validate behavior and give the agent actionable failure output
Demo: “Fix the lint errors” — letting the agent run commands and verify repairs
Lee demonstrates a minimal prompt—“Fix the lint errors”—and the agent autonomously runs the project’s lint command, diagnoses issues, applies changes, and re-runs lint to confirm success. The key takeaway is outcome-based prompting and self-verification.
- •Agent discovers and runs the correct command (e.g., `bun run lint`)
- •Finds issues like unsafe `any` typing and formatting problems
- •Applies targeted edits, then re-runs lint to confirm the fix
- •GPS metaphor: specify destination, not step-by-step instructions
Learning from the agent: reviewing diffs and graduating to manual terminal use
Claire emphasizes inspecting the agent’s changes to build intuition and confidence. Even if the agent runs terminal commands, users can learn them and re-run checks themselves inside Cursor’s terminal.
- •Diff review helps beginners connect errors to specific code changes
- •Agent output becomes a tutorial: you learn commands like running lint
- •Terminal stays optional early, but becomes accessible over time
- •AI-generated code still needs scrutiny; cleanup workflows keep code maintainable
Parallelizing work: keeping focus while the agent “cooks” on the side
Lee describes using the agent for parallel tasks while continuing manual work in the editor. This pattern evolves AI from a code generator into a true pair programmer as users learn when to delegate versus take control.
- •Main task in the editor; secondary tasks delegated to the agent panel
- •Run background changes (e.g., adding a route/feature) without blocking flow
- •As familiarity grows, the user “grabs the wheel” more intentionally
- •Effective collaboration depends on clear scope and guardrails
Custom rules and reusable commands: codifying preferences and preventing repeat mistakes
Lee explains using Cursor rules when a model repeats the same mistakes. He shows defining reusable agent commands (like a code review) and building them iteratively as living prompts tailored to the repo.
- •Create rules after repeated undesired behavior to steer future outputs
- •Define custom commands (e.g., `code review`) for consistent workflows
- •Commands can check for offline/loading issues, unnecessary changes, tests, auth risk
- •Prompts evolve over time as you notice new patterns to enforce
Using @mentions for better context: files, Git branches/commits, and more
The episode highlights the @mention menu as a key mechanism for giving structured context to the agent. Lee explains how referencing Git branches and commits helps the model review exactly what changed.
- •@mention menu supports injecting precise context into prompts
- •Git integration: reference a branch (all working changes) or a specific commit
- •Faster than manually describing changes; reduces misunderstanding
- •Useful for reviews, debugging, and targeted feature work
Choosing models without overwhelm: Auto mode vs picking reasoning models
Claire asks why Lee keeps the agent on Auto model selection, and Lee explains it as a beginner-friendly default that optimizes for quality, speed, and availability. Advanced users can then intentionally choose specific models for tasks like deeper reasoning.
- •Auto chooses a “best fit” model based on speed/quality/availability
- •Model selection complexity can distract beginners from learning workflows
- •Reasoning models (e.g., GPT with “brain” indicator) for harder tasks
- •Over time, users learn quirks and styles of different models
Micro-slicing agent chats: managing context limits and avoiding degraded quality
They discuss context usage as a percentage and how long chats can reduce quality as the model “forgets” earlier details. The recommended approach is to start new chats per discrete feature and keep side questions in separate threads.
- •Context % indicates how full the chat’s memory window is
- •Quality can degrade at high context; Cursor may summarize at 100%
- •Start fresh chats for discrete features to keep instructions crisp
- •Use separate chats for one-off questions to avoid derailing the main task
Beyond code: using AI as a writing “linter” with banned words and LLM-pattern checks
Lee shows a large writing prompt he uses (often in the ChatGPT macOS app) to polish emails, posts, and messages. The prompt functions like a linter/formatter for prose—banning generic marketing phrases and flagging telltale AI patterns.
- •“Mega prompt” encodes tone, style preferences, and explicit banned words/phrases
- •Reduces generic marketing language; forces specificity and concrete benefits
- •Tracks common LLM tics (over-listing, certain constructions like “not just X, it’s Y”)
- •Best used as a reviewer pass; rules are meant to be broken intentionally
Lightning round: who should use which tools, how to learn, and how to re-prompt under stress
Lee maps the ecosystem from vibe-coding tools for first-time builders to Cursor as the bridge toward real maintenance and professionalism. He recommends JavaScript or Python for learning fundamentals and stresses calm, specific re-prompts when models go off track.
- •Vibe coding as an on-ramp; Cursor as the step where code understanding becomes necessary
- •Belief: long-term maintainability requires learning some code, even with great models
- •Learning paths: JavaScript (instant browser feedback) and Python (readable syntax)
- •When AI fails: stop, specify what’s wrong and what you actually want—don’t just vent
