30:40Theo - t3․gg · Tutorial
Mythos is here, it's time to start tokenmaxxing
A 30-minute field report on burning $5,400 of subsidized AI inference in ten days — and what actually came out of it.
June 12thThe argument in one line.
Most developers waste time fighting Claude Code because they're missing six critical features—memory, custom commands, MCP servers, task-based sub-agents, plugins, and code ownership—that turn it from a liability into a solo developer's force multiplier.
Read if. Skip if.
READ IF YOU ARE…
- A solo developer or small team member shipping features fast who finds Claude Code outputs require heavy iteration and refinement before production use.
- A developer with 1-3 years of programming experience who uses Claude Code occasionally but hasn't built systematic workflows around memory, commands, or documentation lookup.
- Someone building SaaS or indie products who loses hours to context switching between Claude, documentation searches, and manual prompt repetition across sessions.
SKIP IF…
- You're a Claude Code power user with 200+ hours already logged who has built custom MCP servers or extensive command libraries—this covers foundational patterns you've likely optimized past.
- You work primarily in non-code domains or use Claude for non-development tasks like writing or research—the six features discussed are engineering-specific.
- You're evaluating whether to adopt Claude Code at all rather than seeking workflow optimization—this assumes you're already committed to the tool.
The full version, fast.
Eight hundred hours inside Claude Code reveals that most developers underuse it because they skip the configuration layer that makes the tool actually compound. The mechanism is a six-part stack: a CLAUDE.md memory file so you stop repeating instructions, a personal slash-command library for repetitive prompts, the Context7 MCP server for live framework docs, sub-agents scoped to narrow tasks rather than human-style roles, the new Plugins system for bundling and sharing setups, and a discipline of reviewing AI output before shipping. Treat sub-agents as context-saving task workers, not autonomous teammates. Write precise prompts or use plan mode to clarify intent first, then own every line the model generates before it reaches production.
Free for members
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.
00:00 – 00:44
01 · Cold open + promise
B-roll of KL high-rise workspace. Reddit thread, GitHub bug report #3382. Promise: 800 hours, private workflows, six core features most developers miss.
00:44 – 02:09
02 · Memory & Commands
CLAUDE.md via # key, project vs. global scope. Building a .claude/commands/ library sorted into subdirectories. $ARGUMENTS for reusable flexible commands.
02:09 – 03:59
03 · MCP Servers
Context7 MCP as live-docs hub — 'just add two words: use context7'. MCP architecture explained simply. Supabase, Playwright, Stripe, and Vercel MCPs recommended.
04:02 – 05:35
04 · Sub-Agents
Sub-agents are isolated Claude instances with their own context window. Key lesson: define by task, not role. Burned $500 in 5 days learning role-based agents don't work. UI/UX reviewer via Playwright as working example.
05:36 – 06:31
05 · Plugins
Anthropic Plugins bundle commands + agents + MCPs into a shareable package. Clone a power user's entire workflow with one command.
06:31 – 07:53
06 · Mindset
Garbage in = garbage out. Prompt engineering forces clearer thinking. Plan mode for Q&A before code. AI generates code but humans own it.
Lines worth screenshotting.
- The hash key shortcut for adding instructions to CLAUDE.md mid-conversation lets you capture a preference or decision without stopping the current task to open a file.
- Custom slash commands in a ~/.claude/commands/ directory turn any repeated prompt pattern into a reusable keyboard shortcut — a library of commands is faster than any autocomplete.
- Context7 MCP fetches live documentation for popular coding libraries, solving the training-data cutoff problem that causes AI to generate deprecated API calls.
- Adding 'use context7' to any prompt is enough to trigger the MCP — the agent automatically fetches the specific documentation section relevant to the current task.
- Sub-agents should be defined by task, not role — assigning a sub-agent to be a front-end developer produces worse results than assigning it to review UI components in the browser.
- A sub-agent connected to Playwright MCP can autonomously open the app, inspect UI components, and return design feedback without consuming tokens from the main agent's context window.
- The Plugins feature lets you bundle a complete Claude Code setup — commands, sub-agents, MCP servers — into one installable package that other users can clone in seconds.
- Supabase MCP lets Claude query the app's live database, run migrations, and create new tables directly — removing the copy-paste step between the database dashboard and the code.
- Stripe MCP and Vercel MCP provide the same pattern: the agent can make changes to payment configuration or deployment settings without the developer switching tools.
- After 800 hours, Edmund Yong's hardest-won lesson is that owning what AI generates — understanding it, being able to explain it, being responsible for it — is non-negotiable for a solo developer.
- Building sub-agents for parallel tasks — front end, API endpoints, database migrations — collapses a sequential workflow into simultaneous work streams that finish in a fraction of the time.
- Most developers who find Claude Code frustrating are missing the setup: CLAUDE.md memory, custom commands, and targeted MCP servers are the three things that make the tool work for you instead of against you.
Six Claude Code Features That Remove the Most Common Sources of Friction for Solo Developers
Claude Code workflows
Edmund Yong's 800-hour distillation shows that the gap between fighting Claude Code and flowing with it is almost always a setup problem — and that the six features most developers miss (memory, commands, live-docs MCP, task-based sub-agents, plugins, and ownership mindset) each address a distinct friction point.
02Memory & Commands
- # key adds memory at project or global scope — project scope for per-repo rules, global scope for preferences that apply everywhere
- .claude/commands/ library with subdirectories and $ARGUMENTS makes repetitive prompts into reusable commands — build it incrementally as you notice repetition
03MCP Servers
- Context7 MCP routes documentation queries to live sources — 'use context7' appended to any library question eliminates hallucinated API signatures
- Supabase, Playwright, Stripe, and Vercel MCPs address the most common external service integration points for web developers
04Sub-Agents
- Sub-agents are isolated Claude instances with their own context window — the isolation is what makes them reliable for parallel or sequential tasks
- Define by task, not role: 'review this component with Playwright and report layout issues' outperforms 'be a senior UI/UX reviewer' — the task definition has a clear completion state
05Plugins
- Plugins bundle commands, agents, and MCPs into a shareable package — one install command gives you an entire workflow configuration
- Cloning a power user's plugin is the fastest way to understand how they have structured their workflow
06Mindset
- Garbage in equals garbage out — AI generates code but you own it; the quality of the output is bounded by the quality of your thinking before the prompt
- Plan mode (Q&A before code) forces clarity that makes the subsequent implementation faster and the output better
Terms worth knowing.
- Claude Code
- Anthropic's command-line coding assistant that runs in a developer's terminal, edits files, runs commands, and integrates with external tools and documentation.
- CLAUDE.md
- A markdown memory file the assistant reads at the start of every session, used to store persistent instructions, conventions, and context either per-project or globally.
- Slash commands
- Reusable prompt shortcuts saved as markdown files in a commands directory, invoked with a forward slash to trigger repeatable tasks without retyping the full prompt.
- MCP server
- A Model Context Protocol server that connects an AI assistant to external tools or data sources such as databases, APIs, or browsers, expanding what the agent can do beyond text generation.
- Context7
- An MCP server that fetches up-to-date documentation for popular coding libraries on demand, so the AI references current docs instead of stale training data.
- Supabase
- An open-source backend platform built on Postgres that provides a database, auth, and storage; an MCP server lets an AI query it, run migrations, and create tables.
- Chrome DevTools MCP
- An MCP server that lets the AI drive a Chrome browser, inspect the DOM, and read console logs to debug front-end issues autonomously.
- Playwright MCP
- An MCP server exposing the Playwright browser automation library so an AI can control a real browser, navigate pages, and run end-to-end tests.
- Stripe MCP
- An MCP server that gives the AI controlled access to the Stripe payments API for setting up products, prices, and checkout flows from inside a coding session.
- Vercel MCP
- An MCP server connecting the AI to the Vercel hosting platform for reading docs, inspecting deployments, and adjusting project settings.
- Sub-agents
- Isolated assistant instances spawned by a main orchestrator agent, each with its own context window, system prompt, and tool permissions, used to run focused tasks in parallel.
- Context window
- The amount of text an AI model can consider at once; filling it with irrelevant content degrades reasoning, which is why offloading work to sub-agents is useful.
- Orchestrator agent
- The primary AI instance that coordinates a task, delegates work to sub-agents, and integrates their results back into a single workflow.
- Database migration
- A versioned script that changes a database's schema, such as adding tables or columns, so changes can be applied consistently across environments.
- API endpoint
- A specific URL on a server that accepts requests and returns data, used by front-end applications to read or write information.
- Middleware
- Code that runs between an incoming request and the final handler, typically used for tasks like authentication, logging, or request validation.
- TypeScript linter
- A static analysis tool that scans TypeScript code for style violations, type errors, and likely bugs without running the program.
- Plan mode
- A Claude Code mode that has the assistant produce and confirm a step-by-step plan, often via clarifying questions, before it is allowed to edit any code.
- Plugins
- An Anthropic feature that bundles slash commands, sub-agents, and MCP server configurations into a single installable package so users can adopt another developer's full workflow at once.
- Plugin marketplace
- A registry that lists installable plugin bundles, letting users browse and add prebuilt workflow packages to their Claude Code setup with a single command.
Things they pointed at.
03:16linkAwesome MCP Servers (GitHub repo)
01:55linkClaude Code Slash Commands (GitHub repo)
03:26toolSupabase MCP
03:35toolPlaywright/Chrome DevTools MCP
03:43toolStripe MCP
03:49toolVercel MCP
Lines you could clip.
00:06
“If Claude has ever felt dumb to you at times, then it's likely you're just missing critical parts of the setup.”
02:49
“You just have to add two words into your prompt — use context seven.”
04:57
“I don't think sub agents are at a point yet where you can assign them specific roles and rely on them to brainstorm and work autonomously like a real human would.”
06:54
“Garbage in equals garbage out. If you can't write a prompt that clearly instructs the AI on what to do, then you don't actually know what you want.”
07:39
“Speed means nothing if your app is buggy or insecure.”
Word for word.
Read-along
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.
analogystory
After spending over eight hundred hours in Claude code, I've discovered ways to actually make this thing work for me, not against me, especially at times when I need to move fast as a solo developer. Whether you're churning through tickets at a corporate tech job or attempting to vibe code your next 10 k a month app, if Claude has ever felt dumb to you at times, then it's likely you're just missing critical parts of the setup.
In this video, I'll walk you through my private workflows, essential resources, and teach you the six core features that most developers are unaware of in Claude code. So by the end, you'll be shipping faster with Claude instead of wasting time fighting it.
Before we dive into the advanced workflows and hidden tricks, let's make sure we quickly cover the foundations. These three features have saved me hours of repeating myself to Claude every single session. When I first started using Claude code, I found myself repeating same instructions over and over again.
The easy solution is to make use of Claude's memory. Press the hash key to quickly add some instruction snippets to Claude's memory. You can decide whether you want to apply these instructions locally to the project or globally across all Claude sessions.
And you will see these instructions get saved to the Claude dot m d file. So if you ever change your mind, you can easily edit or remove them. I also found myself typing the same prompts to perform small repetitive tasks like creating a new API endpoint that correctly includes my custom middleware with error handling and type interfaces, or running the TypeScript linter command and fixing all errors around the code base.
This led me to build my own library of custom commands that I can easily call with a few keystrokes. To create your first command, just add a new commands directory within your claud folder, then write out your command in a markdown file. And as your command library grows, you can sort them into subdirectories to keep them organized and easier to find.
You can also make commands accept arguments. This is what allows commands to be more flexible and reusable in different scenarios. So just be conscious of what you are prompting to Claude over and over again, then slowly build up your own command library as you go.
I've also used this GitHub repo which has a bunch of useful commands that I use every day for building. In the early days of building with Claude code, one of my biggest frustrations was making sure it references the latest documentation when building new features or debugging errors, especially with frameworks and libraries that are constantly being updated.
But as you know, AI assistants are only as good as their training data, and forcing it to use web search to fetch the latest data wasn't reliable either. This is where MCP servers come in, specifically one that I use every day called Context seven. It's essentially a service that allows Claude to reference the most up to date documentation for the most popular coding libraries.
And this alone has saved me hours constantly having to Google search and copy and paste the latest docs into my prompts. Now, I can just rely on Context Seven as a centralized source for when I need the AI to reference any kind of documentation. And to use it, you just have to add two words into your prompt.
Use context seven, and Claude will automatically call the server to fetch the latest docs whenever it needs to. And you might be asking, what exactly are MCP servers? To explain it simply, just think of it as a way to connect AI agents to external tools and services.
And this just gives the AI more capabilities for its tasks, like connecting to a database, calling a custom API, or executing code on some remote server. You If would like to know where I browse for MCP servers, here are some great repos that I recommend checking out. Some other MCP servers that I use regularly are Superbase to allow Claude to query data directly from my app's database, apply migrations, or create new tables for any new features I am building.
The Chrome DevTools and Playwright MCP, which gives Claude the ability to autonomously debug and test issues on the front end by letting it control the browser and inspect the DOM and console logs. I also use the Stripe MCP for when I build something that touches the payment side of my app and also the Vercel MCP for when I need to look up the latest documentation or make changes to my project settings.
As a solo developer, my process for building new features used to look something like this. Create the front end UI components, write the API endpoints, and run some database migrations.
This approach wasn't bad, but it just meant I had to do things in a very sequential order, which wasn't very efficient. But ever since I discovered how to properly use Claude's sub agents to do work in parallel, I've been able to build and ship features in a fraction of the time. Firstly, what are sub agents?
They are isolated Claude instances that can work in parallel with each other and feed crucial information back to the main orchestrator agent once it has finished the task. In simple terms, using sub agents will greatly help reduce any pollution to the main context window because each sub agent will get its own context window, system prompt, and tool use permissions.
So they are great for offloading smaller and more specific tasks. But what I see people doing with sub agents is they assign them to act as specific roles, like a front end developer, a UI UX designer, or a product manager. And I can tell you, I spent a good couple of hours trying to work with agents this way, and the results were pretty bad compared to just using Claude code with no agent specific instructions.
Personally, I don't think sub agents are at a point yet where you can assign them specific roles and rely on them to brainstorm and work autonomously like a real human would. But that's okay.
They still saved me a lot of time and effort on tasks is actually good at. What has worked really well for me is to define sub agents for tasks, not roles, like cleaning up and optimizing the code it has just written, generating documentation, or gathering research data from the web.
For example, one of the sub agents I use regularly is this one that reviews the UI UX of my app. It connects to the Playwright MCP server and inspects the UI components of my web app in the browser, and it gives feedback based on the design and usability of the UI components. I think this is the best way to make use of sub agents because it handles work that would have previously taken up precious context tokens from the main agent, and it just helps to maintain a high quality of the overall output.
To create a sub agent, use the slash agents command. Select create a new agent, choose project or personal, select generate with Claude, then describe the sub agent's task in natural language. Customize the tool use permissions and then save.
And to invoke a sub agent, just use natural language or the add symbol to directly call the sub agent within your prompt. Now that I've told you all about slash commands, sub agents, and MCP servers, you might be put off by the thought of having to set up all these tools manually for your own projects. Well luckily, Anthropic recently released a new feature called plugins, which allows users to bundle up their setups into a single package.
So you can literally clone a Claude Power user's entire workflow with a single command. And if you're curious about my personal setup, I've published my own plugin marketplace, which you can add by running this command.
From there, just pick and choose which plugins you would like to install. Feel free to add only what you need. I want to talk about the mindset and expectations I've adopted when working with AI to build apps.
Because after spending hundreds of hours of trial and error using AI to help with coding tests, I found these are the things that have given me the biggest productivity boost. Garbage in equals garbage out. If you can't write a prompt that clearly instructs the AI on what to do, then you don't actually know what you want, and the AI definitely won't either.
I found learning some basic prompt engineering has forced me to break down my problems into smaller pieces, which also clarifies my own thoughts in the process. Or if the idea is still vague in my mind, I will use Claude's plan mode to have a quick q and a session and make it ask me clarifying questions so we can be on the same page before I let it write any code.
AI generates code, but humans own it. Before pushing to production, just start a new session with the AI asking it to review the code on the files it's recently touched. Don't let the AI make you lazy about the fundamentals like security, performance, or error handling.
Because given enough time, if you keep ignoring these things, it will eventually lead to vulnerabilities and bugs if you don't constantly review it. Speed means nothing if your app is buggy or insecure.
So these have been my top tips for getting the most out of Claude code when building apps as a solo developer. Let me know what you think, and I'll see you in the next one. Bye bye.
The Hook
The bait, then the rug-pull.
Edmund Yong opens with a GitHub bug report — Claude saying 'You're absolutely right!' about everything — and a Reddit thread asking if AI tools are now mandatory. Before the first tip lands, the frustration is already validated. Eight minutes later, you have six features that change how the tool behaves.
Named ideas worth stealing.
05:04concept
Task-Based Sub-Agents (not Role-Based)
Assign sub-agents specific bounded tasks (clean up code, generate docs, gather web data, review UI/UX) rather than job titles. Role-based agents burn tokens and produce bad results.
Steal forJoeFlow Sessions dispatching — frame agent tasks as verbs, not personas
01:05model
CLAUDE.md Memory + Commands Library
- Global memory via # key
- Project-scoped memory
- commands/ directory in .claude/
- Subdirectory organization
- $ARGUMENTS for flexible reuse
Build up a personal commands library incrementally as you notice yourself repeating prompts.
Steal forJoeFlow template system — same pattern, same value proposition
06:36concept
Plugins — Shareable Workflow Packages
Anthropic Plugins bundle commands, agents, MCPs into an installable package. One command to clone a power user's full setup.
Steal forMCN+ feature framing: 'install my entire workflow' as a membership perk
06:54concept
Garbage In / Garbage Out
If you can't write a clear prompt, you don't know what you want. Prompt engineering as a forcing function for your own clarity.
Steal forClaude Code onboarding content, LFB Line pre-work framing
How they asked for the click.
VERBAL ASK
07:53next-video
“Let me know what you think, and I'll see you in the next one.”
Soft close, no subscribe ask, no link pitch. Purely conversational.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
AFFILIATECommission earned if you click.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
