The argument in one line.
The quality of your AI-generated software depends entirely on the precision of your planning and prompts, not on using advanced features like agentic loops, so invest heavily in detailed feature specifications and the ask-user-question tool before building anything.
Read if. Skip if.
- A non-technical founder or solo maker who's never used Claude Code and wants to understand the terminal, prompting patterns, and when to deploy agentic loops without feeling overwhelmed.
- A developer new to AI-assisted coding who's built 1-2 small projects and wants a structured mental model for planning, prompt precision, and context management before scaling.
- A startup builder with a specific feature or MVP you want to ship in the next 2-4 weeks using Claude Code but don't know the mechanics or best-practice workflow.
- You're an experienced software engineer who's already shipped 5+ production systems with Claude Code or similar agents — this is foundational-level instruction.
- You're building with other AI coding tools exclusively (Cursor, V0, or OpenAI's Codex) and aren't planning to switch to Claude Code anytime soon.
The full version, fast.
Claude Code quality is determined entirely by input quality — the models are now good enough that slop output means slop input, not a capability ceiling. The crash course covers four foundational principles: communicate with Claude Code the way you'd brief a precise human engineer; use the AskUserQuestionTool planning method to let Claude clarify requirements before writing a single line of code; build feature by feature rather than trying to ship everything in one session; and treat agentic loops as a tool for experienced users rather than a starting point, since beginners who skip the planning step burn context and get confused outputs. Context limits matter and require active management. The audacity principle closes the course: the software worth building in 2026 is whatever feels too ambitious to attempt, because that's the gap where AI makes the impossible practical.
Chat with this breakdown.
Modern Creator members can chat with any breakdown — ask for the hook, quote a framework, find the exact transcript moment. Unlocks at T2: refer 3 friends + add your own API key.
Create a free account →Who's talking.
Where the time goes.

01 · Cold open + guest intro
Greg promises the simplest Claude Code tutorial on the internet. Ross commits to a blueprint by end of episode.

02 · Input quality = output quality
Core thesis: model quality is no longer the bottleneck. Your PRD/plan is. Think in features, not product descriptions. Each feature needs a test before moving to the next.

03 · Live AskUserQuestionTool demo
Ross demos planning a TikTok UGC app. First, standard plan mode (shift+tab). Then he pastes a prompt invoking AskUserQuestionTool -- Claude runs 4+ rounds of granular questions covering workflow, hosting, UI style, video format, and script generation.

04 · Why NOT to use Rolph as a beginner
The Tesla self-driving analogy: learn to drive first. Building feature-by-feature builds vibe QA instincts that agentic loops skip.

05 · How agentic loops work + live demo
Ross explains Ralph Wiggum loops (PRD.md + progress.txt + build + test + lint cycle). Shows his custom loop running a Bun server build live. Reiterates: great loop + bad plan = token donation.

06 · Tips and tricks (live whiteboard)
Ross builds a 5-point list on screen: (1) AskUserQuestionTool, (2) don't obsess over MCP/skills, (3) Rolph only after you've shipped without it, (4) 50% context rule, (5) have audacity.

07 · Audacity + Animo app + wrap
Greg shows the Animo emotion-based running app as a benchmark for taste. Both agree scroll-stopping software requires thought, not just code generation.
Lines worth screenshotting.
- The quality of your output is capped by the quality of your input; in 2026, the models are so good that slop output means slop input.
- Think in features, not products — describe four concrete features and you have a product; describe a product and the AI guesses wrong.
- The right workflow is: build feature one, write a test, make it pass, then and only then move to feature two.
- The AskUserQuestionTool forces Claude to interview you about your own plan, surfacing tradeoffs that auto-generated plans silently skip.
- The terminal is not scary — if you do not know how to use it, ask AI, which is the same tool you are trying to access.
- 95 percent of Anthropic engineers use Claude Code internally, which is the most credible signal that the tool actually works for real engineering.
- By early 2026, skilled engineers are reviewing significantly more code than they write — that ratio will only continue to shift.
Your plan is the product.
The model is no longer the bottleneck - your ability to write a precise, feature-level plan is.
- Add this to your planning prompt: 'Read this plan file and interview me in detail using AskUserQuestionTool about literally anything: technical implementation, UI & UX, concerns, tradeoffs.'
- Think in features with tests, not product descriptions. A feature is done when its test passes, not when it compiles.
- Build your first three features manually before touching any agentic loop. You need the reps.
- Set a 50% context hard limit - start a new session when you hit it. Quality drops fast after that.
- The PRD.md + progress.txt + test-gate loop is the cleanest Rolph pattern. Steal it from Ross's GitHub.
- Audacity is now the moat: every clone is easy, but taste, animations, and feel are still hard. Build scroll-stopping, not feature-complete.
Terms worth knowing.
- Claude Code
- Anthropic's command-line coding agent that runs in a terminal and writes, edits, and tests code on a developer's local machine through natural-language instructions.
- Agent
- An AI system that can take multi-step actions on its own — reading files, running commands, calling tools — to complete a task instead of just returning a single text reply.
- Terminal
- A text-based interface for issuing commands to a computer. Coding agents like Claude Code run inside it rather than in a graphical app window.
- PRD
- Product Requirements Document. A written spec that describes what a product should do, used here as the input file an AI agent reads before generating code.
- Plan mode
- A Claude Code setting, toggled with Shift+Tab, that forces the agent to draft a plan for approval before it touches any files.
- AskUserQuestion tool
- A built-in Claude Code tool that pauses execution to interview the user with multiple-choice questions, surfacing decisions about scope, UX, and trade-offs the agent would otherwise guess at.
- Tokens
- The chunks of text an AI model reads and generates. Usage is metered in tokens, so longer prompts and outputs cost more money and consume more of the model's context window.
- Context window
- The maximum amount of text a model can hold in working memory at once, measured in tokens. Once it fills up, the model starts losing earlier details and quality degrades.
- Ralph (Ralph Wiggum loop)
- A workflow where an AI agent runs in a loop, working through a task list autonomously, marking items done, and continuing until the whole plan is built — named after the Simpsons character.
- Agentic loop
- A self-driving cycle in which an AI agent picks a task, executes it, checks the result, and moves to the next one without human prompting between steps.
- MCP
- Model Context Protocol. An open standard that lets coding agents plug into external tools and data sources, such as databases, APIs, or design apps, through a shared interface.
- Skills
- Reusable instruction bundles that extend a Claude Code agent with specialized capabilities, such as scaffolding a project type or running a specific workflow, invoked on demand.
- Plugins
- Packaged add-ons for Claude Code that bundle skills, commands, and configuration so a workflow can be installed and shared with one step.
- Markdown file (.md)
- A plain-text file with lightweight formatting syntax. Coding agents read files like PRD.md or AGENT.md as instructions, so almost all agent configuration lives in markdown.
- Linting
- Automated checking of source code for style errors, syntax problems, and likely bugs. Agents run linters between feature builds to catch broken code before moving on.
- Endpoints
- URLs on a server that accept requests and return data. Building a backend usually means defining a set of endpoints the frontend or other services can call.
- Modal
- A popup window layered over an app's main interface that requires the user to interact with it before returning to the underlying screen.
- UGC
- User-generated content. In marketing, short-form videos that look like they were filmed by real customers rather than produced by a brand.
- Vibe QA testing
- An informal style of quality assurance where the builder clicks around an app and judges by feel whether it works, instead of running a formal test suite.
- Opus 4.5
- An Anthropic Claude model tier, here referenced as having a roughly 200,000-token context window. Opus is Anthropic's most capable model line, used for harder reasoning and coding tasks.
Things they pointed at.
Lines you could clip.
“If you are producing slop, it's because you've given it slop.”
“If your plan sucks, then the Rolph loop won't matter. You're just donating money to Anthropic.”
“Building personal software is easy, but building software others are going to use is very, very difficult.”
“There isn't a URL that I, myself, or Greg can click on that you've built - you have no business using Rolph.”
“Software development is starting to become easy, but software engineering is very, very hard.”
Where the conversation goes.
Word for word.
The bait, then the rug-pull.
Ross Mike opens with a blunt promise: no other Claude Code tutorial on the internet is this simple. What follows is not a feature tour but a philosophy - garbage in, garbage out - delivered live over a shared whiteboard and a running terminal while Greg Isenberg plays the curious skeptic.









































































