Latest / AI Fire Daily / #51 Robin: Stop Treating Claude Code Like an Intern - 6 Power Phrases to Launch Subagents and Master Vibe Coding
Transcript
- 0:00Picture treating Claude Code like an exhausted
- 0:02intern. You hand over a single task. Right. Just
- 0:05one thing at a time. You sit back and wait for
- 0:07an answer. Then you assign the very next piece.
- 0:10Which is totally sequential. Exactly. Doing this
- 0:13sequentially is a massive mistake. It's actually
- 0:16the fastest way to waste tokens. Tokens are the
- 0:19basic units of data AI reads. Every single prompt
- 0:22resends your previous history. You drain your
- 0:25context window completely dry. And the context
- 0:28window is the AI's short -term memory limit.
- 0:31You end up spending your entire afternoon just
- 0:33waiting for answers. Well, welcome to this deep
- 0:35dive. Today, we're exploring the six power phrases
- 0:38of cloud code efficiency. A lot of developers
- 0:41think faster AI just requires better underlying
- 0:44models. Yeah, or they assume they need to install
- 0:47more external plugins. Or write incredibly complex
- 0:51prompts. We operated under that exact same assumption
- 0:53initially, you know. The real speed jump happens
- 0:56differently, though. it comes from building a
- 0:58highly structured system true speed is not about
- 1:00mashing the gas pedal it requires rethinking
- 1:03the architecture of your workflow that is exactly
- 1:06the shift we need the secret really lies in using
- 1:09six specific phrases these phrases build a system
- 1:12that works in parallel Right. And it forces the
- 1:15AI to plan properly beforehand. It empowers the
- 1:19system to catch its own mistakes. You stop working
- 1:21sequentially and start working systematically.
- 1:23So let's jump in. We must change how we assign
- 1:26the workload. Forcing one session to handle everything
- 1:29just breaks down. That brings us to our first
- 1:32phrase. You want to say, launch subagents to
- 1:35handle this. Launch subagents to handle this.
- 1:37Exactly. This phrase unlocks the sheer power
- 1:40of parallel work. Claude can theoretically spin
- 1:43up subagents by itself. But it rarely uses them
- 1:47when it actually should. The main agent usually
- 1:48tries to do everything alone. It forces heavy
- 1:51lifting into one single context window. Which
- 1:54creates a massive bottleneck for complex projects.
- 1:57It really grinds the whole process down. Take
- 1:59code review as a very practical example. Don't
- 2:02ask for one vague general review. You should
- 2:04launch five specific subagents instead. Yeah.
- 2:08Agent 1 actively checks the code for bugs. Agent
- 2:112 looks exclusively for hidden security flaws.
- 2:14Agent 3 searches for any underlying performance
- 2:17problems. Right. Agent 4 reviews the final user
- 2:20experience flow. And Agent 5 flags any messy
- 2:24code. It's like an assembly line instead of one
- 2:26person running around the factory. Right. And
- 2:28they operate at the exact same time. Every single
- 2:31subagent gets its own specific task. It gets
- 2:34isolated context and its own distinct permissions.
- 2:37Claude eventually brings all those parallel results
- 2:39back together. You end up with a fundamentally
- 2:41cleaner review. Every agent knows exactly what
- 2:44it is responsible for. And it returns its findings
- 2:47ranked strictly by severity. The crucial mistake
- 2:49here involves being far too vague. Vague instructions
- 2:52will absolutely ruin the subagent process. You
- 2:55can't simply say, launch subagents to improve
- 2:58this. That sounds convenient, but it gives Claude
- 3:00too much room. The assigned tasks must be strictly
- 3:03independent. What happens if their assigned resources
- 3:06heavily overlap during this process? They basically
- 3:09trip over each other and waste valuable compute
- 3:11time. You must define what each agent should
- 3:14avoid doing. Keep tasks strictly independent
- 3:17to prevent wasted compute? Exactly. Subagents
- 3:21act as our parallel workers here. But parallel
- 3:24workers without a blueprint just create faster
- 3:26chaos. They definitely do. We need our second
- 3:29power phrase to fix that. Write me an implementation
- 3:31spec. We have to force Claude to write the manual
- 3:34before the code. This solves one of the biggest
- 3:36problems in AI coding. Claude simply cannot read
- 3:40your mind. If you give it a vague build request,
- 3:42it guesses. It guesses the file structure and
- 3:45the core logic. It guesses the necessary tools
- 3:47and the edge cases. Some of those guesses might
- 3:50actually be brilliant, but many will be slightly
- 3:53wrong or misaligned. You waste hours fixing architectural
- 3:56decisions you never actually agreed to. It is
- 3:59incredibly frustrating. Now, Cloud Code does
- 4:01have a built -in plan mode. You trigger it by
- 4:04hitting Shift plus Tab. Right. It helps you plan
- 4:06the immediate short -term work, but you cannot
- 4:09treat it as a comprehensive replacement. You
- 4:12still need a very detailed, overarching implementation
- 4:15spec. Consider Andres Karpathy's specific workflow
- 4:18method here. He prefers writing detailed docs
- 4:21with the agent first. You essentially write the
- 4:23manual before building anything. People always
- 4:25want to skip that planning phase, though. They
- 4:28want the AI to start coding immediately. And
- 4:30then they get annoyed when the output fails.
- 4:32Let's break down the actual math of guessing.
- 4:35Okay. Imagine your upcoming project has three
- 4:37major steps. There are five possible ways to
- 4:40execute each step. That gives Claude five times
- 4:43five times five choices. Yep. 125 possible outcomes.
- 4:48Whoa. Beat. Imagine 125 chaotic timelines shrinking
- 4:55to just one perfect execution. That is the exact
- 4:58mechanism of a proper spec. You reduce the massive
- 5:01guessing game down to one intended build. Claude
- 5:04now understands the intended structural truth.
- 5:06It knows the preferred tools, the order, and
- 5:09the strict constraints. This makes those sub
- 5:11-agents much more effective later. Without a
- 5:13plan, they sprint in completely different directions.
- 5:16With a spec, every agent works from the same
- 5:18foundation. Your prompts need very specific details
- 5:21here. Tell Claude to break the build into clear
- 5:25steps. Force it to highlight key decisions for
- 5:27each step. Make it explain the complex trade
- 5:30-offs behind each decision. Demand asks what
- 5:33it needs from you before building. Never let
- 5:36it start implementation until you explicitly
- 5:38approve the spec. Right. When does an implementation
- 5:41spec become entirely too detailed to use? Well,
- 5:45if the spec takes longer to read than writing
- 5:47the code yourself, you definitely went too far.
- 5:49Focus on key architectural decisions, not every
- 5:52single line. Exactly. Beat. A spec clearly fixes
- 5:56the AI's guessing problem. But what if you were
- 5:59the one guessing? What do you mean? What if you
- 6:01lack the technical details yourself? Ah, that
- 6:03is exactly when you deploy power phrase number
- 6:05three. You tell Claude, interview me. Interview
- 6:08me. This phrase radically flips the entire workflow
- 6:11dynamic. Claude stops acting like a passive builder
- 6:14for a moment. It steps up and acts like a senior
- 6:16project lead. You might know what you want at
- 6:18a high level, but you probably miss the crucial
- 6:22granular details. The database choice, the user
- 6:26flow, the edge cases. Right. The permission rules,
- 6:30the error states, the final review process. These
- 6:33invisible details shape the final product entirely.
- 6:36They really do. I still wrestle with the blank
- 6:38page problem myself when starting out. It's a
- 6:40very common hurdle. That's why this interview
- 6:42phrase matters so much. Claude asks you the questions
- 6:45you may not know to ask. it extracts the vision
- 6:47hiding in your head then it turns your scattered
- 6:51answers into a solid spec there are some very
- 6:53specific rules for this interview process though
- 6:56yeah you must demand that claude asks only one
- 6:59question at a time that is a critical constraint
- 7:01if claude gives you 15 questions at once the
- 7:04process fails you will inevitably rush through
- 7:06them and give weak answers Asking one question
- 7:09at a time creates a real dynamic conversation.
- 7:12You might also want to use voice dictation tools
- 7:14here. Speaking your complex answers often feels
- 7:17much easier than typing them. Tools like Hex
- 7:20or Whisperflow make this highly conversational.
- 7:23It makes the whole architectural process feel
- 7:25much more natural. There is a dangerous trap
- 7:28with this interview phrase, however. Vague answers
- 7:31will ruin the final output entirely. It's a huge
- 7:34trap. If Claude asks who the tool is for, Don't
- 7:37just say founders. That is way too broad and
- 7:40vague. You need to be incredibly specific with
- 7:42your user constraints. Say solo founders who
- 7:46need to review daily customer feedback. That
- 7:49small contextual difference changes the entire
- 7:51build direction. Claude needs to help you actively
- 7:54narrow the idea down. It should ask about the
- 7:56core problem we're actually solving. This stops
- 7:58you from building random, unnecessary features.
- 8:01It asks about the target user to drive specific
- 8:03product choices. and about the non -user to tightly
- 8:07prevent broad scopes. What if I simply do not
- 8:10know the answer to Claude's interview question?
- 8:12You just tell the AI to use its best judgment
- 8:14and explicitly justify the choice later. Just
- 8:17hand the steering wheel back to Claude, the sponsor.
- 8:19Coming back to it, you have a solid spec. You
- 8:22survived the interview. The sub -agents built
- 8:24the code. But AI can be confidently wrong about
- 8:28its work. Beat. It sounds incredibly confident
- 8:31even when the task is incomplete. It might claim
- 8:34the new feature is totally finished. Or it might
- 8:36state the database bug is completely fixed. You
- 8:39test the application and realize something is
- 8:41clearly broken. This creates an incredibly expensive
- 8:44mistake in AI coding workflows. You lose trust
- 8:48and have to manually inspect everything anyway.
- 8:50This risk is why we need power phrase number
- 8:52four. You must tell Claude, verify before you
- 8:56build. This creates a vital automated feedback
- 8:59loop. The engineer Boris Cherny points out something
- 9:01fascinating here. A strong feedback loop improves
- 9:05model results massively. It can improve the final
- 9:08code quality by two to three times. Make Claude
- 9:11explain its detailed verification plan before
- 9:13it touches code. It must state clearly what actual
- 9:16success looks like. It must list the exact diagnostic
- 9:19checks it will run. It must name any external
- 9:21tool it needs to verify work. Maybe it needs
- 9:23a browser to visually inspect a website layout.
- 9:26Or maybe it needs a deployment MCP to confirm
- 9:29an app. A deployment MCP is a tool that publishes
- 9:33your app to the internet. Right. Maybe it needs
- 9:35linting to check recent code changes. Linting
- 9:38refers to automated tools that flag basic code
- 9:41errors. You add this crucial rule directly to
- 9:44your ClawU .md file. ClawU .md is a file storing
- 9:48your project's AI rules. This forces verification
- 9:51to happen on every single task. Doesn't stopping
- 9:54to verify constantly slow down the magic of AI
- 9:57coding? It might feel slightly slower at the
- 10:00very beginning, but fixing invisible architectural
- 10:02errors later is much, much slower. You also need
- 10:06to heavily define your human validation zones.
- 10:08Those zones are boundaries where the AI must
- 10:11stop. Some parts of a project are safe for very
- 10:13fast movement. A landing page color layout is
- 10:16usually very low risk. If Claude accidentally
- 10:18breaks a visual section, you fix it quickly.
- 10:21But other specific parts need strict human approval.
- 10:23The ultimate cost of an error is simply too high.
- 10:26If Claude attempts to change underlying billing
- 10:28logic, you must intervene. You cannot let it
- 10:31run freely with financial data. The same strict
- 10:33rule applies to authentication and user permissions.
- 10:36It heavily applies to production database schemas
- 10:39and security sensitive files. How should Claude
- 10:42react? If a verification check actually fails
- 10:45during the build, it should immediately halt
- 10:47the process, explain the failure clearly, and
- 10:50propose a specific fix. It needs to hit the brakes
- 10:53and propose solutions. Exactly. Setting up these
- 10:55boundaries every single day gets exhausting,
- 10:57though. Two -sec silence. Power phrase number
- 11:00five solves that tediousness entirely. Tell Claude,
- 11:03based on this conversation, build me a skill.
- 11:06After a few days, you notice a very annoying
- 11:09pattern. You keep asking Claude to do the exact
- 11:11same conceptual work. You repeatedly ask it to
- 11:14review code in the same specific format. You
- 11:17ask it to write implementation specs the same
- 11:19way. You keep correcting its tone, file structure,
- 11:22or testing process. A Claude skill is basically
- 11:25a set of reusable targeted instructions. Instead
- 11:29of explaining the long process every time, you
- 11:31package it. You turn a highly successful conversation
- 11:34into something Claude can seamlessly repeat.
- 11:36You are fundamentally altering its base behavior
- 11:39moving forward. Exactly. But most developers
- 11:42think about these skills in the wrong way. They
- 11:44try to invent abstract, complex skills completely
- 11:47from scratch. They create something far too abstract
- 11:49and then never use it again. The right way requires
- 11:52waiting patiently. for real -world success you
- 11:56wait until you finish a highly successful organic
- 11:58workflow then you ask claude to package that
- 12:01exact proven process the biggest upgrade here
- 12:04is adding a dedicated gotcha section the gotchas
- 12:07are the small annoying issues you discover later
- 12:09they cover strange edge cases strict style rules
- 12:12or frequently repeated mistakes Unclear instructions
- 12:16or minor fixes you explained more than once.
- 12:18You update the custom skill to remember these
- 12:20exact contextual issues. For example, always
- 12:23double check off logic before editing user permissions.
- 12:26Or perhaps never use inline styles. Always use
- 12:30Tailwind CSS classes. How many of these custom
- 12:32skills are too many for one single project? If
- 12:35you spend more time searching for the right skill
- 12:38than working, you definitely have too many. Only
- 12:40keep skills that actively save you time. With
- 12:43your custom skills saved, putting everything
- 12:45on autopilot sounds very tempting. It does. But
- 12:48that introduces brand new risks to the system.
- 12:51Beat. This brings us to the sixth and final power
- 12:54phrase. Automate this. People get extremely excited
- 12:58about this specific phrase way too early. It
- 13:01sounds powerful because nobody wants to repeat
- 13:03boring manual work. But automation with Claude
- 13:06code creates a brand new systemic problem. If
- 13:10the underlying output is slightly wrong, you
- 13:12produce bad work faster. Before you automate
- 13:15anything, decide if it truly needs full automation.
- 13:18It might only need a simple augmentation layer
- 13:20instead. Automation means Claude handles the
- 13:22entire process with zero human input. Augmentation
- 13:26means Claude does the heavy lifting, but you
- 13:28still review the result. There are two critical
- 13:30filters to use before automating any task. The
- 13:33first one is called the taste test. Does the
- 13:35task need human judgment or specific brand sense?
- 13:38Writing final sales copy absolutely needs real
- 13:41human taste. Making nuanced product decisions
- 13:44needs taste. Handling sensitive customer complaints
- 13:47needs taste. You should strictly augment these
- 13:50complex tasks. But what if the task is strictly
- 13:53measurable with clear binary rules? Checking
- 13:57if 100 website links are broken is totally measurable.
- 14:00Creating simple daily summaries. or running basic
- 14:03unit tests is measurable. Sorting simple IP support
- 14:07tickets is measurable. You can safely, fully
- 14:09automate these repetitive tasks. The second critical
- 14:12filter is the 80 -20 output check. If the final
- 14:16output was only 80 % good, would you survive?
- 14:19If the answer is yes, full automation may be
- 14:22perfectly fine. If the answer is no, you must
- 14:25keep a human in the loop. I have to push back
- 14:28on that framework a bit. Isn't settling for 80
- 14:31% defeating the purpose of a high -end AI tool?
- 14:34Not necessarily, because context dictates the
- 14:36value of the output. Right. Getting 80 % accuracy
- 14:39on 100 broken links saves you hours of tedious
- 14:42time. You can easily fix the remaining 20 % manually.
- 14:45But an 80 % success rate on a checkout sales
- 14:47page, that missing 20 % loses you actual revenue.
- 14:51Never fully automate changing payment gateways
- 14:53or deep security logic. You must also be incredibly
- 14:56careful with things like hooks. Hooks are automated
- 15:00triggers that run code in the background. A bad
- 15:02one -time output is slightly annoying. A bad
- 15:05scheduled workflow can keep running and creating
- 15:08endless systemic problems. How do we safely combine
- 15:11full automation with our parallel subagents?
- 15:14Have one subagent thoroughly design the automation
- 15:16workflow and another explicitly hunt for potential
- 15:20failure cases. Use one agent to build, another
- 15:23to test limits. Yep. Two sec silence. We need
- 15:27to step back and look at the big picture here.
- 15:29Speed in AI is not about mashing the gas pedal
- 15:32on simple prompts. It really is not. It is about
- 15:34building a highly structured parallel system.
- 15:37You use independent subagents when you need deep
- 15:40parallel work. You write a strict implementation
- 15:42spec before building anything at all. You let
- 15:45Claude interview you when the core idea is still
- 15:47unclear. You build a secure system that verifies
- 15:50its own output safely. It learns from past conversational
- 15:53successes by building custom skills. It respects
- 15:55human judgment and understands strict operational
- 15:57boundaries. You actively choose thoughtful augmentation
- 16:01over blind automation when taste truly matters.
- 16:04Used properly together, these six phrases give
- 16:07you a much cleaner way to build. The process
- 16:09becomes faster, highly structured, and requires
- 16:12far fewer messy fixes later. We want you to pick
- 16:15just one of these power phrases today. Try implementing
- 16:18it in your very next Claude Code session. I highly
- 16:21recommend starting with the interview me script
- 16:24flip. It immediately changes how you interact
- 16:26with the underlying model. Try flipping the script
- 16:29today and consider this final thought as we wrap
- 16:32up. Yeah. If Claude Code is fully capable of
- 16:35interviewing you. If it can actively plan the
- 16:37entire architectural build. If it can assign
- 16:39its own parallel sub -agents to execute tasks.
- 16:42If it can rigorously verify its own work against
- 16:45your rules. At what point do you stop being the
- 16:48coder and officially become the CEO of your own
- 16:50digital agency? Outro music.