The beginner's guide to coding with Cursor | Lee Robinson (Head of AI education)

Lee Robinson is the head of AI education at Cursor, where he teaches people how to build software with AI. Previously, he helped build Vercel and Next.js as an early employee. In this episode, he demonstrates how Cursor's AI-powered code editor bridges the gap between beginners and experienced developers through automated error fixing, parallel task execution, and writing assistance. Lee walks through practical examples of using Cursor's agent to improve code quality, manage technical debt, and even enhance your writing by eliminating common AI patterns and clichés. *What you'll learn:* 1. How to use Cursor's AI agent to automatically detect and fix linting errors without needing to understand complex terminal commands 2. A workflow for running parallel coding tasks by focusing on your main work while the agent handles secondary features in the background 3. Why setting up typed languages, linters, formatters, and tests creates guardrails that help AI tools generate better code 4. How to create custom commands for code reviews that automatically check for security issues, test coverage, and other quality concerns 5. A technique for improving your writing by creating a custom prompt with banned words and phrases that eliminates AI-generated patterns 6. Strategies for managing context in AI conversations to maintain high-quality responses and avoid degradation 7. Why looking at code—even when you don't fully understand it—is one of the best ways to learn programming *Brought to you by:* Google Gemini—Your everyday AI assistant Persona—Trusted identity verification for any use case *Where to find Lee Robinson:* Twitter/X: https://twitter.com/leeerob Website: https://leerob.com *Where to find Claire Vo:* ChatPRD: https://www.chatprd.ai/ Website: https://clairevo.com/ LinkedIn: https://www.linkedin.com/in/clairevo/ X: https://x.com/clairevo *In this episode, we cover:* (00:00) Introduction to Lee (02:04) Understanding Cursor's three-panel interface (06:27) The importance of typed languages, linters, and tests (11:28) Demo: Using the agent to automatically fix lint errors (15:17) Running parallel coding tasks with the agent (18:50) Setting up custom rules (23:24) Understanding the different AI models (24:48) Micro-slicing agent chats for better success (27:22) Tips for effective agent usage (29:00) Using AI to improve your writing (35:47) Lightning round and final thoughts *Tools referenced:* • Cursor: https://cursor.com/ • ChatGPT: https://chat.openai.com/ • JavaScript: https://developer.mozilla.org/en-US/docs/Web/JavaScript • Python: https://www.python.org/ • TypeScript: https://www.typescriptlang.org/ • Git: https://git-scm.com/ *Other references:* • Linting: https://en.wikipedia.org/wiki/Lint_(software) _Production and marketing by https://penname.co/._ _For inquiries about sponsoring the podcast, email jordan@penname.co._

Claire VohostLee Robinsonguest

Sep 22, 202545mWatch on YouTube ↗

WHAT IT’S REALLY ABOUT

Cursor coding guide: agents, linting, rules, and better writing workflows

Cursor is presented as an AI code editor that blends a traditional IDE with agentic workflows, letting users work from basic autocomplete up to an autonomous agent that can read files, run commands, and apply verified changes.
Lee explains how adding classic software engineering “guardrails” (TypeScript/typed languages, linters, formatters, and tests) dramatically improves agent reliability because the AI can read failures and correct itself.
They demo an agent fixing lint errors end-to-end (run lint → identify issues → patch code → rerun lint to verify), then discuss running parallel tasks in the background while you keep coding.
The conversation also covers power features—@-mentioning Git context, custom rules and reusable commands like “code review,” model selection (Auto vs manual), chat/context management—and ends with a writing workflow that uses a “banned words/phrases” prompt to reduce AI-sounding copy.

IDEAS WORTH REMEMBERING

5 ideas

Treat Cursor as a spectrum: autocomplete → agent.

Lee frames Cursor’s UI as progressive autonomy: basic inline suggestions, then higher-autonomy agent actions that can create files and make multi-step changes. This helps beginners start small while giving pros leverage for bigger tasks.

Add engineering guardrails to make agents consistently useful.

Typed languages, linters, formatters, and tests provide machine-readable feedback loops. When an agent causes or encounters failures, it can interpret the errors and correct itself rather than guessing blindly.

Use agents for closed-loop fixes: run → detect → patch → verify.

The lint demo shows the ideal agent pattern: it runs the lint command, applies fixes, and reruns lint to confirm success. This “GPS, not turn-by-turn” approach reduces manual instruction and catches regressions early.

Always inspect diffs to learn and stay in control.

Claire emphasizes opening the red/green diff to understand what changed—especially for beginners. Reviewing diffs teaches code structure, builds trust, and prevents silent mistakes from being merged.

Run parallel agent tasks to keep momentum.

Lee describes keeping focus in the main editor while delegating side tasks (e.g., creating a new route) to the agent panel “in the background.” This turns the agent into a true pair programmer rather than a single-threaded bottleneck.

WORDS WORTH SAVING

5 quotes

Rather than giving you step-by-step instructions, you're just putting the thing into the GPS, and it just figures it out along the way.

— Lee Robinson

There are tools that you can take from traditional software engineering... and apply them to make your code more resilient to errors and help the AI models fix errors for you.

— Lee Robinson

You can't just vibe code your way forever.

— Lee Robinson

It's a linter and a formatter.

— Claire Vo

When I re-prompt... and I'm not very explicit about what actually wasn't good... the model can't read my mind.

— Lee Robinson

Cursor’s three-panel IDE and autonomy levelsAgent workflow: run commands, patch code, self-verifyGuardrails: TypeScript/types, linters, formatters, testsDiff review and human-in-the-loop learningParallel agent tasks while you codeCustom rules and reusable agent commands (e.g., code review)Model selection, context limits, and chat micro-slicingUsing AI as a writing “linter” (banned phrases, LLM tics)Beginner-to-pro tool progression: vibe coding to real maintenance

High quality AI-generated summary created from speaker-labeled transcript.

Get more out of YouTube videos.

High quality summaries for YouTube videos. Accurate transcripts to search & find moments. Powered by ChatGPT & Claude AI.