Latest / AI Fire Daily / #441 Neil: Claude Code Tutorial Build A Full SaaS App While You Sleep
Transcript
- 0:00You know, there is a universal friction we all
- 0:02experience when we sit down to build. Oh, absolutely.
- 0:05You get completely in the zone. The ideas are
- 0:08flowing perfectly. But instead of actually building,
- 0:11you're forced to context switch. Yeah, the worst.
- 0:14You jump over to a terminal window. Then you
- 0:16flip to a browser tab to read some documentation.
- 0:19Right. Then you tab over to a separate chat box.
- 0:22Two secs silence. It completely fractures your
- 0:25flow state. We've spent decades adapting our
- 0:28brains to how computers organize information.
- 0:30Which is pretty unnatural, honestly. It is. So
- 0:33what if your entire digital workspace lived inside
- 0:36one intelligent window? That is the holy grail,
- 0:40isn't it? Yeah. We leak so much cognitive energy
- 0:42just shuttling context between different apps.
- 0:46Our brains really aren't wired for that kind
- 0:47of constant switching. Welcome to the Deep Dive.
- 0:50Today we're... We're exploring the new Claude
- 0:53Code desktop app. Yeah, and we are basing this
- 0:55on the architect's manual. But we aren't just
- 0:58going to read you a feature list today. We're
- 1:00exploring a fundamental shift in how builders
- 1:02operate. We're looking at how this app moves
- 1:04away from being a simple chat box. It acts more
- 1:07like a unified workshop. Yes. We're going to
- 1:09break down the philosophy behind plan mode. We'll
- 1:12look at the future of work through automated
- 1:14routines. And we'll honestly examine where the
- 1:18illusion breaks down. It's a massive behavioral
- 1:20shift. Yeah. I'm really eager to unpack the psychology
- 1:23here, how this tool actually changes our daily
- 1:26workflows. Let's start with the physical architecture
- 1:28of this new space. To understand how the AI operates
- 1:32differently here, we have to look at the layout.
- 1:35The manual highlights three specific tabs at
- 1:37the top, chat .co -work and code. Clicking that
- 1:42code tab opens a dark focused workspace. It immediately
- 1:46sets a different tone. It feels like a serious
- 1:48developer environment. It certainly doesn't feel
- 1:50like a conversational chatbot anymore. You're
- 1:53presented with this brilliant three -pane layout.
- 1:55So on the far left, you have mission control.
- 1:57That's where your project lists and active sessions
- 1:59live. Then the middle column is your active session
- 2:02that holds your chat thread and your input box.
- 2:05And the right side is this flexible zone for
- 2:09extra panes. That right pane is where the magic
- 2:11happens. You can open a preview pane to see your
- 2:13app running or... a plan view to see architecture
- 2:16or diff view to see exact code changes. The layout
- 2:20relies heavily on drag and drop. It's about reducing
- 2:22cognitive load. If you're reviewing a massive
- 2:25code refactor, you don't want to squint at a
- 2:27tiny box. Exactly. You just grab that diff view
- 2:30and drag it to take up the whole screen. Yeah.
- 2:32Or maybe you're tweaking user interface colors.
- 2:35You can drag the live preview right next to the
- 2:38chat. It completely eliminates that endless alt
- 2:41-tabbing we're all so used to doing. The analogy
- 2:43in the original manual didn't quite capture the
- 2:45mechanism for me. Oh, really? Yeah. Working with
- 2:48old AI web chats felt like working at a tiny
- 2:51cluttered desk. Right. But this new layout, it
- 2:54feels more like stacking Leo blocks of data on
- 2:57a massive multi -room factory floor. Oh, I like
- 3:00that. Because with the old web chats, the AI
- 3:03overheard every single conversation. It would
- 3:07hallucinate code from a marketing site you asked
- 3:09about three days ago. Yeah, that cross -contamination
- 3:12is incredibly frustrating. So this new layout
- 3:14uses a project -first model. The AI is placed
- 3:17in a soundproof room. It only has access to the
- 3:20specific blueprints you slide under the door.
- 3:22Work is strictly separated by folders. And that
- 3:25folder boundary is enforced mechanically. It
- 3:28uses something called Git work trees underneath
- 3:30the hood. Let's define that jargon really quickly.
- 3:32Sure. A Git work tree is basically a way to work
- 3:34on different parts of code at once. That's spot
- 3:37on. Agent A can be completely rewriting your
- 3:40payment module. At the exact same moment, Agent
- 3:43B is writing unit tests for your user login.
- 3:46Wow. Yeah, they don't step on each other's toes
- 3:48at all. So the workspace is organized, but an
- 3:50empty room doesn't write software. Why is this
- 3:53isolated folder -based context such a massive
- 3:56game changer compared to the old chat threads?
- 3:58Because language models are highly susceptible
- 4:01to noise, when you isolate the context to a single
- 4:04folder, the AI's attention mechanism becomes
- 4:08hyper -focused. It doesn't have to guess which
- 4:11version of a file you care about. So clean folders
- 4:13mean the AI never pulls context from the wrong
- 4:15project. It's a hard, impenetrable boundary.
- 4:18So the physical space is set, but how do we actually
- 4:21breathe life into it? The first decision a user
- 4:23makes actually dictates the AI's entire operating
- 4:26boundary. Right. And you have to set the foundation
- 4:29properly. This requires a fresh installation
- 4:31of the desktop app. And, crucially, it requires
- 4:35a Claude Pro subscription. The manual mentions
- 4:37the free tier is mostly just for testing the
- 4:40visual layout. Yeah, because the AI is reading
- 4:42your entire project folder, the context window
- 4:44fills up immediately. You'll hit the free limits
- 4:46in minutes. You really need the pro plan for
- 4:49this workflow. Let's pause and talk about the
- 4:51economics of that. The pro plan is roughly $20
- 4:54a month. According to the source, that gives
- 4:56you about 44 ,000 tokens per 5 -hour Watto. That
- 5:00translates to anywhere from 10 to 40 prompts.
- 5:02But I have to push back a bit here. That scarcity
- 5:05fundamentally changes the relationship, doesn't
- 5:07it? 44 ,000 tokens can run out fast on heavy
- 5:10code bases. Users really need to be strategic.
- 5:14Oh, it absolutely does. You can't just spam the
- 5:17AI with lazy half -baked thoughts anymore. You
- 5:20have to treat every single prompt like an expensive
- 5:23managerial directive. Which means choosing your
- 5:26operating environment carefully. When you boot
- 5:29up a session, you get three choices. Local, Remote,
- 5:32or SSH. Right. Let's explore the implications
- 5:35of those choices. Local is your speed layer.
- 5:38It runs directly on your local machine and reads
- 5:40your file system natively. It skips the delays
- 5:43of pushing and pulling from a cloud repository.
- 5:45It's incredibly fast for rapid iteration. The
- 5:48manual notes Windows users need Git installed
- 5:50for that while Macs have it natively. What about
- 5:52the remote environment? Remote operates completely
- 5:55differently. It runs safely on Anthropic's cloud
- 5:58infrastructure. The brilliant part is that it
- 6:00survives even if you close your laptop. Oh, wow.
- 6:02Yeah. It's much safer for delicate client projects
- 6:05because changes are stored in a dedicated branch
- 6:08with a full history. And SSH is the third option.
- 6:11SSH just allows the session to tunnel into a
- 6:13remote server that you control. It's great for
- 6:16folks managing their own bare metal hardware.
- 6:18So we have our environment. Next is the model
- 6:20selection. We have Claude Sonnet 4 .6 and Claude
- 6:24Opus 4 .7. Think of Sonnet as your highly caffeinated
- 6:28junior developer. It's fast, it's great for daily
- 6:31tasks, simple UI changes, and quick bug fixes.
- 6:35And Opus. Opus is your lead architect. You bring
- 6:38in Opus for deep reasoning, complex database
- 6:41migrations, or massive architectural shifts.
- 6:44There's also an effort selector. You can choose
- 6:46low, medium, high, or auto. They simplified that
- 6:49nicely. Low effort means the agent moves quickly
- 6:52and doesn't overthink small tweaks. High effort
- 6:55forces the model into a deeper chain of thought
- 6:57process before it touches a single line of code.
- 7:00But the real leverage seems to be hidden. There's
- 7:02a subtle menu inside the input box that a lot
- 7:04of people overlook. Oh, the context menu. It
- 7:06is the nerve center of the whole application.
- 7:08You click that little icon and a massive set
- 7:10of tools opens up. You can inject specific reference
- 7:13files. You can pull live GitHub issues directly
- 7:16into the AI's working memory. And you have connectors.
- 7:20You can seamlessly link the session to your Gmail,
- 7:23your Slack channels, or your Notion workspaces.
- 7:25Right. You also access your skills from that
- 7:27menu and the transcript mode where you can toggle
- 7:30between verbose, normal, or summary. It's an
- 7:33incredible amount of power right at the cursor.
- 7:36So for someone starting a brand new project this
- 7:38afternoon, how should they choose between local
- 7:41and remote environments? I always recommend starting
- 7:44local. You want that tight, immediate feedback
- 7:46loop when you're initially prototyping. Once
- 7:49the foundational architecture is stable, you
- 7:51shift the session to remote. That protects the
- 7:53code base with a continuous cloud history. Local
- 7:55for speed and testing, remote for safe, continuous
- 7:58cloud history. Exactly right. So we've established
- 8:02that tokens are precious. We can't afford sloppy
- 8:05meandering mistakes to sex islands. Jumping straight
- 8:08into coding is usually what causes those expensive
- 8:11errors. There is a specific feature designed
- 8:14to purposely slow the AI down. Plan mode. I genuinely
- 8:19believe it's the most profoundly undervalued
- 8:21feature in the entire ecosystem. To understand
- 8:24plan mode, we first have to look at the permission
- 8:26states. The default state is ask permissions.
- 8:29Right. It's incredibly safe. but painfully slow.
- 8:33The AI pauses to ask your permission before every
- 8:36single file edit. Then you have the opposite
- 8:39end of the spectrum. Auto accept edits. The agent
- 8:42runs wild. It writes files, edits code, and executes
- 8:45terminal commands freely. It only pauses for
- 8:48highly destructive actions, like deleting a directory.
- 8:51And sitting outside of both of those is plan
- 8:53mode. Plan mode forces the AI to put its hands
- 8:56behind its back. It drafts a highly detailed
- 8:59comprehensive roadmap and pure markdown. You
- 9:01get structured headings, you get code blocks,
- 9:04but it absolutely refuses to write project code
- 9:06immediately. The manual provides a brilliant
- 9:08example of this constraint in action. You tell
- 9:11the agent you want to build an on -chain token
- 9:12watch list application, but before it writes
- 9:15anything, you command it to ask you five highly
- 9:17targeted questions about scope, auth, and the
- 9:20tech stack. I love that workflow. You force the
- 9:22AI to interrogate you. It asks about your target
- 9:25audience. It asks about your preferred database
- 9:27structure. And the incredible part is, the AI
- 9:30actually stops and waits for your answers. It
- 9:32does. It sits there patiently. Once you answer,
- 9:35it generates a meticulous step -by -step build
- 9:38plan. It outlines the precise file structure,
- 9:41the API endpoints, and the UI components. It
- 9:44forces alignment before a single token is wasted
- 9:47on bad code. I'll make a vulnerable admission
- 9:50right here. beat. I still wrestle with prompt
- 9:52drift myself. Oh yeah. Yeah. I get so impatient
- 9:55when I try to skip the planning phase. I see
- 9:57that blinking cursor and I just want the dopamine
- 10:00hit of watching code generate on the screen.
- 10:02We are all guilty of that. We've been conditioned
- 10:04by standard chatbots to expect instant gratification.
- 10:07But skipping plan mode on a fresh build is a
- 10:10devastating trap. You inevitably spend three
- 10:12times as many tokens untangling a spaghetti code
- 10:15mess three hours later. You review the draft
- 10:17in the dedicated plan pane. You spot the missing
- 10:19logic. You correct it. Only then do you switch
- 10:22the permissions to accept edits. It's the ultimate
- 10:25preventative measure. But to be fair, you shouldn't
- 10:28use it for everything. Right. The manual notes
- 10:31that plan mode is gold for new builds, but it's
- 10:33massive overkill for fixing a simple CSS alignment
- 10:36issue or a tiny bug. If you just need a button
- 10:39move five pixels to the left, use auto accept
- 10:41edits. Feed the agent the exact file name and
- 10:44the exact line number. Don't overcomplicate small
- 10:48chores. That does make me wonder about the psychological
- 10:51friction. Does forcing yourself into plan mode
- 10:54kill the momentum of rapid prototyping? It definitely
- 10:56feels slower in the first 15 minutes, but it
- 10:59is exponentially faster by hour three. The AI
- 11:03catches fatal architectural flaws before they're
- 11:05ever coded into existence. Plan mode actually
- 11:08saves hours by preventing massive code rewrites
- 11:10later. Measure twice, cut once. It's timeless
- 11:13advice. Sponsor. So the workspace is set. The
- 11:16architectural plan is rock solid. But the execution
- 11:18phase is where this tool breaks out of being
- 11:20just a fancy text editor. This brings us to the
- 11:23new automation capabilities, routines, and skills.
- 11:27Routines are where we start seeing the future
- 11:29of software development. Anthropic rolled these
- 11:32out on April 14, 2026 as a research preview.
- 11:36Let's unpack what a routine actually is. At its
- 11:39core, a routine is a cloud -based configuration
- 11:42that runs automatically. It bundles together
- 11:44a specific prompt, a target repository, and the
- 11:47necessary API connectors. And crucially, it runs
- 11:51completely autonomously on Anthropic's cloud.
- 11:53Which means your laptop can be closed and stored
- 11:55in your backpack. Exactly. It operates entirely
- 11:57independently of your local hardware. The manual
- 12:00details three specific ways to trigger these
- 12:03routines. Let's walk through them. The first
- 12:05is schedule triggers. These use standard Krone
- 12:07expressions. You can configure a routine to run
- 12:10every night at midnight or every Monday morning.
- 12:13Anthropic currently caps the frequency at once
- 12:15per hour to manage compute loads. The second
- 12:17trigger is what really caught my eye. API triggers.
- 12:21Every single routine is assigned its own unique
- 12:23HTTP endpoint. Right. You just had a simple POST
- 12:27request with an authentication token and the
- 12:29AI session boots up in the cloud. Wow. Imagine
- 12:33wiring that API trigger directly up to your deploy
- 12:36hooks. You could literally have the AI review
- 12:40your code while you sleep. It's mind blowing.
- 12:43You literally wake up to a fully vetted perfectly
- 12:46documented pull request. It's essentially a tireless
- 12:50junior engineer working the graveyard shift.
- 12:52Yeah. And that perfectly segues into the third
- 12:55trigger type, GitHub triggers. The AI listens
- 12:58to the repository's heartbeat. Yes. It natively
- 13:01subscribes to specific repository events. If
- 13:04someone opens a new pull request or cuts a new
- 13:06release, the routine automatically springs into
- 13:09action. Wow. You just have to authorize the Cloud
- 13:11GitHub app first. The source material gives a
- 13:14brilliantly practical example of a schedule trigger,
- 13:16the 7 a .m. daily morning brief. It's such a
- 13:19clever quality of life hack. Every weekday morning
- 13:21at exactly 7 a .m., the routine quietly spins
- 13:24up. It uses the Gmail connector to read your
- 13:26inbox. It scans for urgent deadlines or missed
- 13:29payments. Then it reads your Google Calendar
- 13:31for the day. Without you touching a single key.
- 13:33Right. It synthesizes all that chaotic information
- 13:36into a clean, structured markdown document. Finally,
- 13:40it uses the Flac connector to drop that brief
- 13:43directly into your private channel before you
- 13:45even wake up. That's a beautiful example of cross
- 13:47-platform orchestration. But we also need to
- 13:50examine skills, which operate a bit differently.
- 13:52Skills are what transform clogged code from a
- 13:55coding assistant into a customizable work platform.
- 13:59A skill is essentially a deeply ingrained reusable
- 14:02set of instructions loaded on demand. The manual
- 14:05suggests creating a product -led Prad skill.
- 14:08When you invoke it, the AI instantly assumes
- 14:10the persona of a rigorous product manager. It
- 14:13automatically asks seven specific questions about
- 14:16user pain points, demographics, and technical
- 14:18constraints. So instead of copying and pasting
- 14:20that massive prompt from a notes app every single
- 14:23time you have an idea, you just type a slash
- 14:25command. Every new project gets the exact same
- 14:28rigorous treatment. You can load these skills
- 14:30via a zip file or by pasting a terminal command.
- 14:33or even using skills .sh. Yeah, it gives your
- 14:36tool stack immense flexibility. You just have
- 14:38to be careful not to install dozens of them at
- 14:41once, or they start competing for the model's
- 14:43attention. This raises an interesting operational
- 14:45question. How do these native skills actually
- 14:47differ from just keeping a Notion document full
- 14:49of your favorite copy -paste prompts? A Notion
- 14:52document is just dead text. A skill is a living,
- 14:56active tool. When you invoke a skill, it natively
- 15:00configures the agent's internal parameters and
- 15:03runs its built -in slash commands automatically
- 15:06within the session's memory. Skills are native
- 15:08reusable AI tools that automatically run their
- 15:10built -in slash commands. They literally become
- 15:13extensions of the agent's brain. It sounds like
- 15:15a deeply seductive, perfect system, but to actually
- 15:19master it, we have to look past the marketing.
- 15:21We have to understand the underlying mental model,
- 15:23and we have to be brutally honest about where
- 15:25the illusion currently breaks down. The underlying
- 15:28mental model is the skeleton key to this whole
- 15:31app. It breaks down into three very simple components,
- 15:34context, agents, outputs. Let's explore those.
- 15:38Context is simply the folder. Right, but it's
- 15:41not just storage. The folder is the AI's short
- 15:44-term memory. It holds your code base, sure.
- 15:46But it should also hold reference PDFs, brand
- 15:49guidelines, and old architecture docs. The richer
- 15:52the soil in that folder, the better the AI's
- 15:55output. The manual calls out a very specific
- 15:58widespread mistake people make regarding context.
- 16:01Staring at a completely empty folder and typing
- 16:04a massive 500 -word prompt, the agent has absolutely
- 16:07zero grounding. You have to invert that behavior.
- 16:10Fill the folder with dense context first. Right.
- 16:12Then write a very short, highly focused prompt.
- 16:15Let the agent connect the dots. The second pillar
- 16:18is agents. And an agent is not just the underlying
- 16:21language model. That's a crucial distinction.
- 16:24An agent is Claude Opus, combined with your specific
- 16:26permission settings, your active skills, and
- 16:28your enabled connectors. You can run the exact
- 16:30same underlying model with different rule sets,
- 16:32and you will get wildly different behaviors.
- 16:35And the final pillar is outputs. Code is the
- 16:37obvious answer here. But the output can be anything
- 16:39now. It can be a fully formatted markdown brief.
- 16:43It can be a visual Canva design. It can be a
- 16:45complex calendar invite. The AI seamlessly moves
- 16:50across mediums without ever leaving that single
- 16:52window. You really start treating the interface
- 16:54like a small, highly capable team. But let's
- 16:58look at the rough edges. The manual is surprisingly
- 17:00candid about what still feels clunky or broken.
- 17:03The most glaring omission is the lack of a proper
- 17:06file viewer. There is no native file tree panel
- 17:09inside the application yet. Which is maddening
- 17:12if you're a visual thinker. You can't just click
- 17:13folders to see how the project is structured.
- 17:15You have to ask the AI to print out the directory
- 17:18structure. So for now, you end up keeping standard
- 17:21VS Code open on a second monitor just to maintain
- 17:24your spatial awareness of the project. I have
- 17:26to thoughtfully challenge this all -in -one workspace
- 17:28claim then. Oh. If a builder still needs VS Code
- 17:31open to see their files, and they still need
- 17:33Chrome DevTools open to debug their CSS, then
- 17:35this isn't truly a single window workspace. It's
- 17:38just a prettier terminal. I see why it feels
- 17:40that way. But I think you're looking at the wrong
- 17:43layer of abstraction. Clod code isn't trying
- 17:46to replace your IDE's file explorer. It's trying
- 17:49to replace your hands on the keyboard. Think
- 17:52of it like a manager's control room. You don't
- 17:54need to hold the wrench if you're directing the
- 17:56mechanic. That's a fascinating reframe. The preview
- 17:59console is another area that feels a bit hollow.
- 18:01It is very lightweight. You only get basic session
- 18:03logs. If you hit a complex front -end bug, the
- 18:08internal preview won't give you the deep inspection
- 18:10tools you need. You still have to open the local
- 18:12server in a real browser. And the cloud sandboxes
- 18:14have their own friction. They feel sluggish on
- 18:16that initial boot. It can take a solid minute
- 18:19or two to spin up a fresh GitHub branch sandbox
- 18:21in the cloud. That's why local is so crucial
- 18:24for the fast, messy iteration phase. So, knowing
- 18:28all these intricate mechanics, the folder rules,
- 18:30the token limits, the missing file trees... How
- 18:33should users handle the situation when the AI
- 18:35inevitably generates a terrible output, rather
- 18:38than just blaming the model's intelligence? You
- 18:41have to audit the environment you built for it.
- 18:43Did you fail to provide a key reference document
- 18:46in the folder? Are your permission rules too
- 18:49restrictive? The model itself is incredibly capable.
- 18:53The failure is almost always in the managerial
- 18:56setup. Don't blame the model. Fix your folder
- 18:59context or adjust the permission rules. You are
- 19:01the orchestrator now. You have to manage the
- 19:04workspace. Let's pull all these threads together.
- 19:06We've covered a tremendous amount of ground.
- 19:09For someone listening right now, what is the
- 19:10ultimate takeaway? The builders who are moving
- 19:13incredibly fast right now are combining three
- 19:15specific things. Plan mode. Custom skills. and
- 19:19cloud routines. That specific formula is what
- 19:22separates the fast builders from the slow ones.
- 19:25Moving from a chat box mentality to treating
- 19:27the app like a small managed team that ships
- 19:29work for you. It's a complete paradigm shift.
- 19:32It requires patience to learn, but the compounding
- 19:34returns on your time are massive. So here's our
- 19:37call to action for you. Pick one tiny low stakes
- 19:39project today. Open the app, create a strictly
- 19:42isolated folder, boot up a session in plan mode,
- 19:46and write your first architectural prompt. Just
- 19:48get one small win. The initial friction disappears
- 19:52very quickly. Two secs silence. But before we
- 19:55wrap up, I want to leave you with a lingering
- 19:56thought. We started this deep dive talking about
- 19:59the universal frustration of context switching,
- 20:03the deep desire for one intelligent window that
- 20:05understands our intent. We've just explored how
- 20:08Claude code now handles the initial project planning.
- 20:11It writes the PRDs. It executes the raw code.
- 20:14It even summarizes its own results on Slack for
- 20:17you while you sleep. beat. If the AI is handling
- 20:20the planning, the execution, and the reporting,
- 20:22well what exactly is the human's core role in
- 20:24the software loop of 2027? That is a real question
- 20:27we're all going to have to answer. Out to your
- 20:29own music.