The argument in one line.
Master Claude Code by keeping it simple—use the VS Code extension, skip the complex workflows that gurus push, treat idle time as CEO thinking time, and collaborate with Claude as a creative partner instead of just a code executor.
Read if. Skip if.
- A developer who uses Claude Code daily and wants to optimize workflow efficiency through proven patterns rather than chasing every new feature.
- Someone building a commercial product with Claude Code who needs practical lessons on token management, tool setup, and long-term sustainable practices.
- A content creator or developer advocate documenting Claude Code lessons who wants to avoid common beginner mistakes and understand what actually scales.
- You're a hobbyist exploring Claude Code for the first time — this assumes 12+ hours daily hands-on experience and focuses on optimization, not fundamentals.
- You primarily use Claude through the web interface or CLI in Cursor and have no plans to switch to VS Code — most lessons build on the VS Code extension workflow.
The full version, fast.
Nine months of daily Claude Code use produces eight lessons that all bend toward radical simplicity. The thesis: ignore the guru-driven complexity around MCPs, sub-agents, and prompt engineering and let the model do the work it is already capable of. The method is a small stack of habits � run Claude through the Visual Studio Code extension, switch the model to Haiku so Sonnet plans and Haiku executes, keep a nine-rule CLAUDE.md that forces step-by-step thinking and forbids lazy temporary fixes, paste UI screenshots from v0 or Pinterest instead of describing layouts, and treat the AI as a brainstorm partner before entering plan mode. Reclaim the eighty percent idle time by running a parallel CEO chat instead of doom-scrolling.
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.

01 · Intro & credibility setup
Alex establishes authority: 9 months daily use, $300K/year app, 50K subscribers, 8 lessons nobody else talks about.

02 · Lesson 1: Use the VS Code extension
VS Code extension beats CLI-in-Cursor for stability and UX. Cursor is a fork; VS Code gets upstream updates first and has zero layout bugs. Free, no subscription.

03 · Lesson 2: Ignore the gurus — keep it simple
Sub-agents, MCPs, 40 slash commands = content-farming noise. Sonnet 4.5 is smart enough to find docs on its own. 99.9% of users need nothing beyond a clear prompt.

04 · Lesson 3: Select Haiku for 10x credit efficiency
With /model Haiku selected, Claude still uses Sonnet for plan-mode planning but drops to Haiku for implementation. Thorough Sonnet plan + Haiku execution = same quality, fraction of the cost.

05 · Lesson 4: Don't waste downtime — Copilot CEO
80% of vibe-coding time is idle wait. YC's Plinko IDE = worst product ever made. Use idle time with a desktop AI chat as co-pilot CEO: feature roadmap, marketing, life decisions. Doom-scrolling is the alternative.

06 · Lesson 5: Nine-rule CLAUDE.md
Nine rules that eliminate lazy loops and whack-a-mole bugs: structured todo plan, check-in before execution, step-by-step explanations, simplicity above all, DO NOT BE LAZY x2, no temporary fixes.

07 · Lesson 6: Prompt engineering is dead
Complex context/UI/database/schema prompt templates are useless. Plan mode handles context discovery. Just tell it what you want. Simple natural language beats structured prompting every time.

08 · Lesson 7: Always include screenshots for UI
Default Claude UI = blue and purple gradients, always. Fix: drag in a v0 design system screenshot or Pinterest app-design board image alongside any UI prompt. Screenshot = art direction Claude can actually follow.

09 · Lesson 8: Treat Claude as a creative partner
Before plan mode, run brainstorm mode: ask Claude for options, what to add, what to change. Demo: asks about folder system, Claude suggests hashtag tagging — that idea wasn't Alex's, it came from Claude and made it into the app.

10 · Recap & CTA
Three-point recap: keep it simple, don't waste downtime, the AI is smarter than you think. Subscribe, newsletter CTA, alexfinn.ai/subscribe.
Lines worth screenshotting.
- The VS Code Claude Code extension has zero compatibility issues because VS Code is the base — Cursor and other AI IDEs are forks that introduce instability.
- Adding MCPs, sub-agents, and custom slash commands beyond what you actually need is complexity theater that degrades output quality.
- Sonnet plans the feature while Haiku executes it — this split captures 90% of the quality at a fraction of the token cost.
- Selecting Haiku as your model in Claude Code does not disable Sonnet; Sonnet still handles the plan phase automatically.
- Idle time while Claude Code runs is CEO time — use it to think about strategy, not to watch the terminal output.
- Nine rules in CLAUDE.md is the proven upper bound; below nine, Claude lacks enough context; above nine, it starts ignoring rules.
- Prompt engineering videos about Claude Code are mostly noise — the model is smart enough that clear intent outperforms elaborate instruction scaffolding.
- Dragging a screenshot of a target UI directly into Claude Code produces more accurate front-end output than describing the design in words.
- Using Claude as a creative partner before entering plan mode surfaces options and tradeoffs that plan mode will miss if you skip the ideation phase.
- A $300K/year app built on Claude Code validates that the tool is production-ready, not just a prototype accelerator.
- Context window management is the primary skill that separates power users from beginners — most perceived model degradation is actually context bloat.
- The creator who ships a working product in six months of Claude Code use outperforms a team that debates the optimal agent architecture for the same period.
The nine rules that end lazy loops.
Alex's CLAUDE.md is the most copy-paste-ready artifact in the video — and the Brainstorm Mode → Plan Mode sequence is the single most underused pattern in Claude Code.
- Drop Alex's nine rules into your project CLAUDE.md verbatim. Rules 8-9 in ALL CAPS — that's not style, it's a behavior change.
- Before entering plan mode on any JoeFlow Sessions run, spend 2 minutes in brainstorm mode. Ask Claude what it would change. The hashtag idea came from Claude, not Alex.
- Switch to /model Haiku for any session burning credits fast. Sonnet plans + Haiku executes = same output at a fraction of the cost.
- The 'copilot CEO during idle time' framing maps directly to the JoeFlow Sessions cockpit — the gap between agent runs is exactly where this applies.
- Drag a v0 design-system screenshot into any UI prompt. Stop accepting blue-purple gradient defaults.
- The meta-lesson: Alex's channel wins by talking back to over-complication. Every new wave of tooling (MCPs, sub-agents, slash commands) creates a new cohort of beginners to address. That's a repeatable content formula worth stealing.
Terms worth knowing.
- Claude Code extension (VS Code)
- The official Visual Studio Code plugin for Claude Code that provides a graphical chat interface, multiple simultaneous sessions, and built-in slash commands — an alternative to the command-line interface.
- CLI (Command-Line Interface)
- A text-based way of interacting with software by typing commands into a terminal, rather than using a graphical user interface.
- Cursor
- An AI-powered code editor forked from Visual Studio Code that integrates large language models directly into the editing experience for autocomplete, chat, and code generation.
- Claude Haiku
- Anthropic's smallest and fastest Claude model, optimized for low token cost and high-speed tasks, well-suited for routine or lightweight coding operations where full reasoning is unnecessary.
- Token efficiency
- The practice of achieving the same task output while consuming fewer tokens (the units AI models charge for), reducing cost and keeping context usage low.
- Plan mode
- A Claude Code workflow where the AI first outputs a detailed plan of changes before executing them, giving the user a chance to review and approve the approach.
- CLAUDE.md rules
- Persistent behavioral instructions stored in a project's CLAUDE.md file — such as coding conventions or output format requirements — that Claude Code reads and follows across every session.
- Sub-agent
- A specialized AI agent spawned by a parent Claude Code session to handle a focused subtask autonomously, returning results to the main session.
- MCP (Model Context Protocol)
- A standard that allows Claude and other AI models to connect to external tools and services through a plugin interface, extending what the model can do beyond text generation.
Things they pointed at.
Lines you could clip.
“Stop listening to all the gurus. You don't need to use every single feature inside Claude code.”
“I saw this tweet from Y Combinator yesterday, and it literally made me sick to my stomach.”
“If you spend 80% of your day scrolling TikTok, your brain's melting out of your ears.”
“Prompt engineering is the most overrated concept in history.”
“It's not just some junior dev going out writing code for you. It's your partner.”
Word for word.
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
The bait, then the rug-pull.
Nine months. Twelve hours a day. A $300K/year app and fifty thousand subscribers built almost entirely inside one tool. Alex Finn has probably logged more hours in Claude Code than anyone outside Anthropic — and the lesson he keeps hammering is the one nobody wants to hear: stop adding complexity.
Named ideas worth stealing.
Alex Finn's 9-Rule CLAUDE.md
- Think through the problem, read codebase, write plan to tasks/todo.md
- Plan = checkable todo list
- Check in before executing
- Work through todos, mark complete as you go
- Give high-level explanation of each change
- Make every change as simple as possible — minimal code impact
- Add review section to todo.md
- DO NOT BE LAZY. NEVER BE LAZY. FIND ROOT CAUSE. NO TEMPORARY FIXES.
- SIMPLICITY ABOVE ALL. MINIMUM CODE IMPACT. ZERO NEW BUGS.
Nine rules delivered as prompts in CLAUDE.md that prevent lazy loops, whack-a-mole bugs, and over-engineered solutions. Rules 8 and 9 are all-caps by design — it changes the model's behavior.
Brainstorm Mode → Plan Mode
Before entering plan mode (shift-tab x2), first run a free-form brainstorm: ask Claude for options, what features to add, what it would change. Only then switch to plan mode with your chosen direction. Separates idea generation from execution planning.
Sonnet Plan + Haiku Execute
Use /model to select Haiku. Claude Code still uses Sonnet for plan-mode planning (shift-tab x2), then drops to Haiku for the implementation pass. A thorough Sonnet plan is detailed enough for Haiku to execute without quality loss.
How they asked for the click.
“Sign up for the number one AI newsletter on planet Earth. It's completely free. Link down below. Alexfinn.ai/subscribe.”
Soft — recap comes first, then subscribe ask, then newsletter. No hard sell. Mirrors the video's 'keep it simple' ethos.






































































