YT YouTube2Text

YouTube2Text → Transcripts → Claude Code New Features, Explained

Claude Code New Features, Explained — Transcript

by Greg Isenberg · 8,225 words · 1,178 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00I think there's a lot of people using
0:02claude code wrong. And they're using
0:04claude code wrong because it is one of
0:06the most powerful pieces of technology
0:10that have ever existed. And there's a
0:12way to use cloud code that spin up
0:14actual AI employees. But the thing is,
0:18you have to set it up in a certain way.
0:21And today, I'm going to show you what
0:23that certain way is. I'm going to show
0:25you the nine different areas that you
0:27need to master in order to spin up these
0:30AI employees. And this episode might
0:33feel a little boring at times because
0:35I'm going through a setup. I'm teaching
0:37you how to actually do it. But I think
0:39that the people that actually stick to
0:41the end, the people that actually get
0:43their hands dirty, that copy what I do,
0:46and I'm going to give away all the
0:47prompts and all the sauce in this
0:49episode, are going to be able to
0:51outperform people, are going to be able
0:52to build products that work 24/7, are
0:55[music] going to build AI native
0:57companies. AI native companies that just
1:00are able to crush. And I'm so excited to
1:04put this together for a free course for
1:08how to master cloud code like no one
1:10ever before with AI agents that run 24/7
1:15that act like AI employees. Enjoy the
1:17episode. Shout out to Anthropic for
1:20supporting the channel and sponsoring
1:22today's episode. [music]
1:30>> [music]
1:31>> The way I think about an AI employee and
1:34setting it up is actually pretty simple.
1:36If you want to if you want cloud code to
1:38act more like an employee, you need to
1:40give it the same basic things you would
1:43give a person joining your company. It
1:45only makes sense, right? First, it needs
1:47a workspace. In this case, the workspace
1:50is called a repo. And that's where the
1:52product actually lives. That's where the
1:55files live. And that's where Claude can
1:57actually go and do the work. Second
2:00thing it needs is memory. Memory is
2:03basically the context that you put into
2:05the project. So Claude understands what
2:08you're building, who the customer is,
2:11what matters right now, what good work
2:13looks like, and we'll get into that
2:15later, and what you've already learned
2:17so it doesn't repeat mistakes.
2:20Then it needs a brief before Claude is
2:24like changing things all around. you
2:26wanted to understand the assignment. So
2:28that's where this thing called plan mode
2:30is super super useful. You're basically
2:32saying, "Look around, read the context,
2:34think through the job, and tell me how
2:36you'd approach it before you touch
2:38anything." And for something like that,
2:40you might want to use like a fable over
2:42an opus. We'll talk more about that.
2:45Then it needs a clear ticket, basically
2:47an assignment. You know, a real employee
2:49does better with an assignment. Why
2:51wouldn't an AI employee? Claude is the
2:53exact same. The mistake a lot of people
2:56make is they'll say, "Make the app
2:57better. Make this pop." These very vague
3:00prompts uh that are assigned to it. The
3:05better way to do it is to be extremely
3:07specific. So, if you're, you know, want
3:08if you're creating a landing page and
3:10you want to create a weight list form,
3:12you'd say add a weightless form to the
3:15landing page with a success state and
3:18check it in desktop preview. That's
3:20going to work just a lot better. The
3:23next thing it needs is eyes, you know,
3:26and you can finally do this in cloud
3:28code, and it's so so exciting. So, uh,
3:31you can do it in the desktop app, which
3:34is what I I primarily use. You can just
3:37say, "Claude, open the app, look at the
3:40page, click through the flow, inspect
3:42what is confusing, and tell me like what
3:45a customer would actually experience by
3:47going through this." That's obviously
3:50very very different level of usefulness
3:52than only editing files. Then it needs
3:56review. So review is just going to look
3:58at the before and after changes. So
4:01Claude can help review the work too, but
4:03you want a system where changes get
4:06actually checked against your standards
4:09before anything important ships.
4:12Um then it needs a schedule. Um, so this
4:16is when a lot of people start having
4:18that aha moment where it's an actual 247
4:22employee. You can basically give Claude
4:24recurring work like a morning brief,
4:27weekly issue review, poll request
4:29reviews. Um, Claude calls this routines
4:32and we'll get into that uh in in this
4:35episode. And the last thing it needs is
4:37permissions. So a good employee knows
4:39what it can do on its own or when it
4:42should ask you for permission. Cloud is
4:44the exact same way. Um, so it could read
4:47files, it could inspect the repo, it
4:49could run tests, uh, it can work on
4:51small branches, but before touching
4:53things like dependencies, before
4:55touching migrations, before touching
4:58payments, a thing, these like bigger
5:00things, you basically want to make sure
5:02that the human owns those trust
5:04decisions. And that's basically the map.
5:07So the map is basically workspace,
5:09memory, ticket, eyes, reviews, schedule,
5:12and permissions. And if you're able to
5:15do that, that's what I mean by an AI
5:17employee. It's basically this working
5:19system. Um, you give Claude a place to
5:21work, context to understand the
5:23business, you give it a clear way to
5:25plan, a way to execute, a way to check
5:27the product, a way to review things, a
5:30few recurring responsibilities that
5:32happen every single day. and then you
5:34give boundaries so it doesn't do
5:36something super risky. And once you set
5:38it up this way, cloud code starts to
5:41feel less of like a one-off chat thing
5:43and really more of like an operating
5:46layer for your company. So let's talk
5:48about how you can actually set up the
5:50first step, which is creating a
5:51workspace. So in cloud desktop, you're
5:54going to want to hit the cloud code
5:57section. Um I prefer using it in the
5:59desktop app. It's a lot less
6:02overwhelming than in the terminal. So,
6:04we're going to use use that today. Um,
6:07you're going to want to go and select
6:08your project folder
6:10um where Claude actually goes and runs.
6:13And just for the sake of this demo,
6:14we're going to talk about an idea that I
6:16found on ideabrows.com,
6:18which is basically a mislead responder
6:20for med spa med spas. So, basically,
6:24someone fills out a form, DMs the
6:25business, calls after hours, uh, ask
6:28about pricing, but the business responds
6:30too late. There's an opportunity to
6:32create a cash flowing uh, software
6:34business there. So, we're going to talk
6:36about how we'd actually set up this
6:38repo,
6:40what the structure would be, and what
6:43what I would want to do if I'm set if
6:45I'm creating an app, if I'm creating a
6:46software, I want basically slash
6:48app/context/c
6:50customers/spec/demo/
6:53routines. I'm going to want 3MD files.
6:56And I'm going to talk about what all
6:58that means. So slash app is the product
7:02slashcontext is the business brain
7:05slashc customers is where the sales
7:07calls the support notes any objections
7:10customer language you put that there uh
7:12slashdemos is where you're going to want
7:14to put the demo flows loom scripts
7:16screenshots things like that routines is
7:19where you're going to want to put those
7:20recurring prompts like we talked about
7:22these like recurring tasks that are
7:24going to happen that'll be in the
7:26routines and then the the three root
7:28file files that you're going to want to
7:30have uh the that are MD files that are
7:33basically like this operating manual for
7:35you are going to be claw.md
7:38which tells you how claude to work. It
7:41you're going to want a roadmap.md
7:43file that's going to tell claude what
7:46matters right now and you're going to
7:48want a review.md file which is going to
7:50tell Claude how to judge the work before
7:53it chips.
7:55So the mo the the first the the takeaway
7:58I want you to have is claude gets just
8:00way more useful when the project
8:03explains itself. So how do you actually
8:05go and set this thing things up? What
8:08are what are what's like the the best
8:10way to do it? This this is what you
8:13should do. So here's the prompt. Help me
8:16set up this repo as an AI employee
8:18workspace. And then you just say create
8:20or update claw.md roadmap
8:22review/context/c
8:24customer/spec/demo
8:26routines. And then you say use this
8:29business context. So you can say product
8:32miss lead responsive for med spa. So
8:34you're just basically saying what it is.
8:37The buyer you want to explain who the
8:39buyer is. So in this case it's a med spa
8:41owner and operator. The pain that they
8:43go through. So the inbound leads are
8:45going cold when the team replies too
8:47late. the promise which is respond to
8:50every missed lead before they book some
8:53somewhere else. So you've identified you
8:55know what success looks like here and
8:57then the goal the current goal build a
9:00simple landing page and demo flow and
9:02then this is very helpful to write this
9:05before writing ask me for any missing
9:07context that would materially change the
9:09setup and keep the first version simple.
9:12That's all you need to set up your
9:14workspace.
9:16um while while you know you can do it
9:19manually but the best way to do it is
9:21just h have this all set up um and you
9:24can see here it's going to say I'll ask
9:26you a few highleverage questions first
9:29the answers change how I structure the
9:31demo flow and the customer spec folder
9:34everything else I'll fill with sensible
9:36defaults and keep V1 so it's going to go
9:39and ask me a bunch of questions
9:42um you know I'm going to go and answer
9:44it really quickly
9:45Um, and based on that, it's going to set
9:49up my entire workspace so it's
9:51optimized. So, you know, it's it's the
9:54way I think see it is like you're
9:56setting yourself up for success. If you
9:59don't have all, you know, an optimi the
10:01optimized MD files and the optimized uh
10:04places uh and folders, then you're
10:07you're, you know, cloud code is going to
10:11trip here and there. So, we're going to
10:13go ahead and uh allow here. And it goes
10:16and creates the the setup. Okay. So, now
10:20we've got all the files and folders
10:22created. You can see here you got the
10:23cloud MD file, the AI employee operating
10:26ma manual, business in one line, we've
10:28got the roadmap.mmd,
10:30uh we've got the review.md.
10:32We've got the folders there, but we need
10:34to optimize it more. So, um I got this
10:37prompt ready. How do you optimize a
10:39claude MD file so it actually feels more
10:42like an AI employee? You have to give it
10:44a working style, right? If you hired a
10:47junior employee, any employee, you would
10:49want to be like, "This is how I would
10:51like you to work." So, you give it the
10:53work style. You say, "I want small
10:55reviewable changes. I want you to
10:57explain the plan before editing when the
10:59task affects product behavior. I want to
11:02keep the changes focused. I want you to
11:04use the existing code style. I want you
11:07to run relevant checks after changes and
11:09I want you to summarize what's changed,
11:11what you tested and what needs human
11:13review. You want it to, you know, have
11:17business context too, right? So you you
11:19create a business context section. You
11:21say the product helps med spas respond
11:24to missed inbounds leads faster. So
11:26you're reminding it what what are we
11:27doing here? The here's who the buyer is.
11:30It's an owner and operator. And you you
11:32give it the promise. Again, you tell it
11:34what the quality bar is as well. You
11:36say, you know, the landing page should
11:38be clear in 5 seconds. The demo flow
11:41should work on desktop and mobile. You
11:42use specific customer language. All this
11:45stuff you're putting in your cloud. MD
11:47file because you want to just you want
11:50it to know how you work. What is what
11:53that you know what does success look
11:55like to you? Um and just you're guiding
11:58you're guiding you're mentoring you're
12:00mentoring it. So we've now gone and
12:01optimized the cloud.MD MD file. Really,
12:04really helpful to do. All right. So,
12:06it's updated my claw.md. It's actually
12:08updated my review.md, but I'm going to
12:10talk about how we can do give it even
12:12more feedback on review.mmd. The next
12:15step I want to do is is basically tell
12:17claude what it needs to focus on this
12:20week. So, we're going to talk about uh
12:24how you can optimize the road roadmap.md
12:27file, which is basically what is your
12:29goal this week. So I say the current
12:33goal is to build a simple simple demo
12:36that shows how a medka med spa can
12:38recover misleads. And this week I want
12:41you to focus on a landing page, a weight
12:43list form, a demo flow, and then sending
12:46looms to 10 med spa owners. An important
12:50thing to do is what here is out of
12:52scope. So I'm including that payments
12:54are out of scope, CRM integration, admin
12:56dashboards, multi-user permissions. And
12:59the reason I'm doing this is I want it
13:00to basically cook on the MVP. I want it
13:04to be like exceed my expectations. So
13:06that's what I'm going to do to optimize
13:08the roadmap.md
13:10file. Now, how can you optimize the
13:14review MD file? This is the file that
13:16knows your standards, what you know what
13:21looks like to you, uh what is acceptable
13:24and not acceptable. So I've got a prompt
13:26here for that. Um, here's my review
13:28checklist. So, I say before shipping, I
13:31want you to does change match the
13:33current road map. Is the change small
13:34enough to review? Does the main user
13:36flow still work? Are there mobile layout
13:38issues? Are form errors handed handled
13:42correctly? Are there off, payment, or
13:44production data risk? Did we add
13:46unnecessary complexity? And because
13:48we're building a landing page, we want
13:49to say, can a first-time visitor
13:51understand the offer in 5 seconds? Is
13:53the CTA visible? Is the copy specific to
13:56the buyer? And does the page use the
13:58words c would uh customers would
14:00actually use? So, this is specific to my
14:03med spa idea, but you can imagine how
14:05you can use this for whatever idea
14:07you're looking at looking looking at.
14:09And you're basically just you're letting
14:11Claude know that uh hey, you can't just
14:15ship garbage. You know, we can't ship AI
14:17slop. And the beauty about, you know,
14:19Opus 4.8 eight or Fable 5, you know,
14:22with the right MD files and the right
14:24structure and the right brain, it does
14:26such a good job, but it does need this
14:28these guard rails. So, it says the
14:32review.mmd is now complete. The works
14:35workspace scaffolding is essentially
14:37done. Claw.md road map review and all
14:40five folders are populated and
14:42consistent with each other. Um, we just
14:44need to name the product and confirm the
14:47demo is simulated on screen and then we
14:49can go ahead and make progress on this
14:53business idea. Okay, so we've got the
14:54workspace set up. The next step is the
14:57brief. So this is the piece that feels
15:00really small, but it does change the
15:02whole way you're going to use clawed
15:04code. When you give a real person an
15:07important task, you don't just throw the
15:09task over the wall and just hope that
15:11they understand it, right? You talk
15:13through it first. You explain what
15:15you're trying to accomplish, what
15:17matters, what the constraints are, and
15:19what would make the work good, and not a
15:23waste of time. That's how I want you to
15:25think about plan mode. Plan mode is
15:28basically the moment where Claude looks
15:30around the project, reads the contacts,
15:33and thinks through the job, and it shows
15:35you the approach before it starts
15:37changing files. So, for this demo, I
15:40just want to use something that's simple
15:42and concrete. I'm just going to ask
15:44Claude to add a weightless form to the
15:46landing page. But instead of just saying
15:49add a weightless form, I'm going to give
15:50it a real brief. So, I'm going to show
15:53how you'd use plan mode here. So I say
15:56use plan mode. I want to add a weight
15:58list form to the landing page. First
16:00inspect the current app, the claude MD,
16:02the roadmap.mmd, and review.md.
16:05Important that you ask it to do that by
16:07the way. Then you say then give me well
16:09it's important. I'll explain why because
16:11it's it's gathering the context. It's
16:14important to gather the context to get
16:16the best quality output. Then you say
16:17then give me the files that need to
16:19change, the smallest clean
16:20implementation, the user experience, the
16:23risks, how we will verify it, and what
16:26you are intentionally leaving out for
16:28the first version. And you say, "Wait
16:30for my approval before editing as it's
16:34uh cooking right now. The important
16:36thing here is you're now going to have
16:38something to react to. Um, and it's not
16:40it might not be perfect. Um, but you can
16:43say good just keep the front end only
16:45because this is just a demo maybe or
16:47actually connect this to superbase
16:49because I want real submissions or you
16:52know the simp the form isn't simple
16:53enough just give me name, email,
16:55company. Um, you can say things like
16:57don't touch off and payments or the
17:00database yet. So it doesn't need to be
17:02perfect but you're basically starting
17:05with something that is well thought
17:07through.
17:08So now you can see Claude proposed a
17:11plan. Here's the context. It gives me
17:14the files that need to change. It tells
17:16me the smallest clean implementation
17:18with the text stack. It says Nex.js with
17:21TypeScript. Um it tells me the user
17:24experience. It explains what it looks
17:26like, the oneline promise. So I can go
17:28and review all these things. Shows me my
17:30risks like spam and abuse. Um and just
17:35gives me this whole plan. And I then can
17:37go and say accept um if I if I like it
17:40or I can give it I can reject it or
17:42revise it um based on my feedback to it.
17:46So I'll go ahead and accept it. The way
17:49to think about plan mode in general is
17:51that anytime you're doing meaningful
17:52product work, you're probably going to
17:54want to do planning or meaningful work
17:57in general actually. You're going to
17:58want to do some planning. It's worth it.
18:01Um, the way I think about it is it's
18:03like, you know, the quote, measure
18:04twice, cut once. That's what you're
18:07doing here. The next big piece to
18:09understand is the ticket. And this is
18:12where a lot of people accidentally make
18:15Claude worse than it needs to be. So,
18:18Claude code is very good at doing the
18:20work, but it needs to know what done
18:21looks like. And that's basically what a
18:24ticket is. A ticket is a small, clear
18:26assignment with a visible finish line.
18:29If you were managing a person, you
18:31probably wouldn't say, "Hey, go and
18:33approve the product," right? You would
18:35say, "Do a specific task like add a
18:37weight list form to the landing page."
18:40It should collect a name and an email
18:42and a company and after someone submits,
18:45show us a simple success message. Um,
18:48and by the way, keep it consistent with
18:50our current brand identity. That is a
18:53good ticket. It gives Claude the job,
18:57the scope, the expected user experience,
19:00and the boundary. So, I'll give you a
19:03few examples of tickets that I would
19:05give to Claude. Create a pricing page
19:08using the existing design system and
19:12keep it consistent with the homepage or
19:15fix the onboarding redirect
19:17bug or fix the onboarding redirect bug
19:20after the email verification.
19:23Um, turn these five customer objections
19:26into a sharper landing page section
19:29section. These are small enough these
19:31are small enough that Claude can
19:32understand the finish line and just get
19:34to work. Um, and you could review the
19:37work afterwards. Um, the there are a
19:40bunch of tickets that do go sideways,
19:43but they're mostly the vague ones,
19:44right? Make the app better, make this
19:46more viral, add AI, build the whole
19:49thing. And the problem with those
19:51prompts is Claude has to guess guess
19:54what matters. And once it starts
19:56guessing, you're no longer managing the
19:58work. You're cleaning up the work. I
20:01will say Fable 5 has done an amazing job
20:04at actually guessing what matters. But I
20:07still believe that this is an important
20:09part of the whole process to get the
20:10most out of it. So after I've approved
20:14the plan, I want to give Claude a prompt
20:16that keeps it really focused. So I say
20:19implement the improved plans as one
20:22focus change. Keep the change small
20:24enough that I review it in the diff
20:26view. I'll explain what diffs are in a
20:28second. After editing, run the relevant
20:31checks. Open up the app in the desktop
20:33preview. Summarize what's changed. Tell
20:35me what you tested and tell me what
20:37still needs human review. The
20:40translation, like what is a diff? The
20:42quick translation is it tells you the
20:44before and after. So, if Claude is going
20:46to go and edit, copy, adding files,
20:48removing files, um, the diff is going to
20:51show you exactly what has changed. And
20:54what's cool is is in the Claude desktop
20:56app, it's it's pretty visual. You can
20:58click into the change files, you can
21:01review edits, you can leave comments,
21:03and you can ask Claude to revise
21:05anything that feels off. And that's
21:07really why ticket size matters so much,
21:10because if it's a small ticket, you can
21:12manage it. But if the ticket is massive,
21:15you end up with a giant pile of changes
21:18that might look impressive, but you
21:20know, it's hard to really trust it. Um,
21:24so the rule here is pretty simple. Give
21:26Claude one clear ticket at a time, which
21:29is one task, one finish line, and one
21:32reviewable change.
21:35So here's the output.
21:37Um, you can see here visually it shows
21:41here's the file, here's what it does.
21:43Here, I'll make this a little bigger.
21:47Um, it's just giving me uh, you know,
21:52it's it's it's changed this shell. It's
21:55done this headline. It's made mobile
21:58first uh, styles. It shows me what has
22:01been tested. It shows me what it
22:03couldn't do and why it couldn't do it.
22:05and it tells me what actually needs
22:08human review. Uh what actually needs
22:10human review
22:12and then we can go from there. So super
22:14helpful. So the fourth piece to
22:17understand is what I call the eyes. So
22:20this is where claude code really starts
22:21to feel like an operator of some sort.
22:24When I say eyes, by the way, I don't
22:25necessarily just mean the visual
22:27preview. I mean Claude needs a way to
22:31inspect work after it builds it, right?
22:33If you think about a good employee, they
22:35do the task and then they check the
22:38task. They open the product, they click
22:40the flow, they run the test, they look
22:42for errors, they check the console,
22:45maybe there's some weird edge case that
22:46they're going to check, they ask, "What
22:48would this actually work for the
22:50customer?" And that's the loop that I
22:52want with cloud code. You know, you
22:55build the thing, you run the thing, you
22:57use the thing, you test the thing, you
22:58improve the thing. The desktop preview
23:01is a is a really big part of that
23:03because product work especially is
23:05visual. A lot of work is visual, but
23:07product work especially. A landing page
23:09can load and still feel really
23:11confusing. A form could submit and then
23:14still kind of be awkward. A button can
23:16be on the page but still be hard to
23:18notice. A headline can explain the
23:21product but still miss the buyer's pain.
23:24So the eyes are are bigger than the
23:26browser preview. It's a bigger idea. You
23:28know, Claude can do things like run the
23:31test suite. It can check console logs.
23:34It can check network errors. Um, check
23:37it could check if the form actually
23:38fills the submission. So, it can do
23:40really anything. And after Claude builds
23:44the weightless form, I actually want
23:46Claude to inspect the whole thing from
23:48the customer's point of view and the
23:51product operator's point of view. So,
23:52we're going to go ahead and check that
23:54and and see how that works. So, here's
23:57my prompt. Start the app and inspect the
24:00weight list flow. Open the landing page
24:02in desktop preview. Check the experience
24:04from the point perspective of a med spa
24:07owner seeing this for the first time.
24:10Then verify the imple implementation.
24:13And then here you say, tell me what what
24:15the buyer understands in the first 5
24:17seconds. What feels confusing or low
24:19trust? Whether the weight list form
24:21works, what happens after submission. So
24:24asking it a bunch of just questions and
24:26then say make one focus pass to improve
24:29the highest impact issue. Again, this is
24:32what a good employee does. Um and we're
24:36just making a part of our process. So
24:39you can see the website has been created
24:42and it's checking to see if it's
24:44rendering correctly. It says now testing
24:46the flows as a firsttime visitor. Empty
24:49submit first. Click join the weight list
24:51with nothing filled. So then it says the
24:53empty state works. It used four tools
24:56for that. Look, you can see it went and
24:57found read the page and used a computer.
25:00I mean this is absolutely insane that it
25:02can actually do this. Um and that's why
25:05this is important to do. You can see the
25:07su success state has rendered. It's
25:09verifying the backend that it wrote the
25:11record. It's checking the console and
25:13network for errors.
25:16Look at this. It says the highest impact
25:18issue. The page asks a cold med spa
25:21owner to hand over their email with no
25:22reassurance about what the weight list
25:26is or whether they'll get spam. This is
25:28the single biggest friction point on the
25:30action the page asked for. My focus pass
25:33add expectation setting microcopy
25:35microcopy at the CTA. Again, this is
25:38really good employee doing doing stuff,
25:41right? This is what you want out of a
25:43good employee. So, it's really cool that
25:45Claude Code has eyes, right? And it's
25:48amazing how few people actually use the
25:51eyes. So when you when you make it a
25:52part of your process, you're going to
25:54have better QA. You're going to have
25:56just better, you know, better product in
25:59the end because you're testing it. Um to
26:02make sure, you know, it could work, it
26:04could do things. It's how you want it.
26:07Um so the eyes underrated.
26:13The next piece we're going to cover is
26:15called review. So this is the part of
26:18the whole AI employee setup that
26:22actually makes it usable because once
26:25Claude can build things click quickly as
26:27you see the bottom the bottleneck moves
26:30to judgment. So did it solve the right
26:32problems? Did it change the right files?
26:35Did it create this like weird edge case?
26:38Um did it make the product clearer for
26:39the customer? Um, that's why the review
26:42matters so much because if you're going
26:44to let Claude do a lot more of your
26:46work, you need a way to inspect that
26:48work without turning every task into
26:51this like hours of code review and stuff
26:54like that. So, I would think about
26:56review in layers. The first layer is
26:59your own read. So, you open the diff
27:03view in in cloud desktop.
27:06Um, like we talked about, a diff is
27:08shows you uh a before and after of
27:10what's changed and look at the files
27:13that Claude has touched. You click
27:15through the changes. You can ask
27:17yourself a few questions like, does this
27:19match the ticket ticket? Does this match
27:22the plan? Is there something surprising
27:24in here? Um, and surprising changes is
27:28usually where the risk is. So, it's an
27:30important question to ask. If Claude was
27:33supposed to add a weight list for him
27:35for example and suddenly it changed O
27:37and routing and databases and stuff like
27:39that I would want to know that
27:42immediately. The second layer is Claude
27:44is reviewing against your standard. So
27:47you remember we created the review.md
27:49file earlier. Well, you're asking Claude
27:53to review the work against what this
27:55project actually cares about. So how do
27:58we prompt Claude code to to go deeper on
28:01this? So, I'm going to say use review.md
28:04as the standard. Review the current
28:07changes for the production issues,
28:09broken edge cases, and confusing user
28:11flows. And then separate issues into
28:14must fix, should fix, and okay to ship.
28:17Focus on bugs, user confusion, security
28:20risks, and unnecessary complexity files,
28:23files change outside the scope of the
28:25ticket, and anything that violates the
28:26road map. So, all that good work that we
28:29did with the review.md upfront is going
28:31to pay dividends. Um, and let's see what
28:35it let's see what come let's see let's
28:37see what they say. So, you can see here
28:39it's separated into mustfix, should fix,
28:43and okay to ship. And you know, it asked
28:46me if I want to fix one and two now.
28:48Good to know, right? If I'm actually
28:50creating an app and putting into
28:52production, you know, it's helpful to
28:54know this sort of stuff. And I just find
28:56this format of must, should, and okay to
29:00be super super helpful. So you can do
29:03slash review
29:05um if you want to just review your your
29:09code. But if you're doing really risky
29:11stuff, you might want to do slash ultra
29:14review. So if you see here, it says
29:15launch a remote remote ultra view
29:18session for this repository. And that's
29:20going to be, you know, before before
29:22you're actually posting in production,
29:24if it's like a big feature, maybe it's
29:26authentication, payments, that sort of
29:28thing, you're going to want to do
29:29something like an ultra review. So, a
29:32little tip, little tip there as well.
29:35The sixth piece is the schedule. Um,
29:38this is basically this idea that the AI
29:41employee is working proactively
29:45for you. So, up until now, we've mostly
29:48been talking about Claude helping you
29:50while you're sitting there with it. And
29:51you got to prompt it and review. You
29:55give it context. You know, you give it a
29:57plan, you give it a ticket, you have it
29:59build, inspect, review the work. I mean,
30:02that's really cool, but an employee is a
30:04bit more valuable in the sense that
30:06they've got this repeating
30:07responsibility
30:09um that they go and do tasks. So, you
30:12know, every business has work like this,
30:14right? like someone has to look at
30:16customer notes or someone has to notice
30:19which issues are coming up. Someone has
30:21to review open task and say, "Hey,
30:23there's a thing on this list that I got
30:25to go do." Um, that kind of work is, you
30:29know, quote unquote boring, not
30:30glamorous, but it's the exactly ex it's
30:33exactly the type of work that keeps a
30:35company moving, that keeps them
30:36progressing, and that keeps them adding
30:38value to customers. So, I would start
30:40right there. Um, I wouldn't start by
30:42asking Claude to ship production code
30:44while I'm asleep. Um, I would start by
30:47just giving it a recurring operator
30:49task. Eventually, you can get to more
30:51cool, glamorous tasks, but I would just
30:55start by, you know, create a morning
30:57brief for me. And this is using a tool
31:00on cloud code called routines. So,
31:03here's a sample routine prompt. I say
31:06every weekday morning at 7 a.m. read
31:08slashc customer slcontext open github
31:12issues if it's connected and then create
31:14or update slashcontext morning brief MD
31:17with the top customer painoint from the
31:19latest notes one product risk one
31:21recommended build task for today and one
31:23question I should ask customers today
31:26don't edit production code don't open a
31:28poll request and keep it under 500
31:30words. Now, this is something that you
31:32can do no matter what you're building,
31:34right? And thank god we got that repo,
31:37right? Slashc customer/context.
31:39Um, and and now you're you're probably
31:41starting to see like how this all kind
31:43of comes together. So, let's set up this
31:46task and see how it works.
31:50Cool. So, that's all done. I like this
31:52task as your first task because it's
31:54it's useful and controlled. It's not
31:57like changing the product. It's not
31:59touching production or anything like
32:00that. It's not building random features.
32:03Just reading the business, looking at
32:05the current work, and giving you a
32:07sharper standing point for the day. So,
32:08this is really cool. Um, and took like a
32:12few seconds to to uh to set up. But what
32:16if you want to take that to the next
32:18level? I would add something like a
32:19weekly ops review. So, let me paste in
32:23the prompt. So, I would say every Friday
32:25at 3 p.m. review open issues and recent
32:28customer notes, group related issues or
32:32identify duplicates. Suggest the single
32:34highest leverage fix for the week and
32:37post the summary to slashcontext/weekly
32:41opsmd. Do not edit code. Done. So, the
32:45second scheduled agent is live. And what
32:48I think is so awesome about this is, you
32:51know, you're not going to have issues
32:52just piling up. Claude is going to help
32:54you see these patterns and maybe there
32:57were customer complaints that you didn't
32:59see. Um, maybe people had the same
33:02onboarding problem and it's going to
33:04help you like prioritize your week and
33:08and it's it's it's almost like a chief
33:10of staff that helps you do that. So now
33:12I have two routines running. You can see
33:14it here, the morning brief and then the
33:17weekly ops review. So, the last thing I
33:20would add here, and I encourage you to
33:22do the same thing, is to create a loop.
33:25How am I going to create a loop? I'm
33:27going to post this uh poll request. So,
33:29I'm going to say when a poll request
33:31opens, review it using review.md.
33:34Leave comments only on issues that could
33:37create bugs, broken user flows, security
33:39problems, or confusing behavior. and
33:42then post a short summary with what
33:44looks good, what needs attention, and
33:46whether this is ready for human review.
33:49Um, so you know, once this is done,
33:52you're going to have every morning
33:54Claude code telling you what matters.
33:56It's going to be telling you the
33:57patterns. Um, and then every pull
34:01request, Claude is going to check that
34:03work against your standards because it's
34:05looking at the review.md.
34:08And that's this whole concept of like
34:09the night shift, right? Like people talk
34:11about, you know, claude code working
34:1424/7. That's what they mean. They mean
34:17that the work is going to continually
34:18get organized. The feedback's getting
34:20summarized over time as it comes in.
34:23Risks for the business are getting
34:25surfaced. And then what you should be
34:28working on, the next set of tasks are
34:30getting clearer and clearer. The next
34:33big piece to understand is how you can
34:35have parallel agents, parallel work
34:38being done at the same time. Obviously,
34:40you don't want to have to, you know, do
34:43one thing at a time. The dream is to
34:46have multiple agents, you know, doing
34:48multiple things at the same time. Um, so
34:51it's not really one employee, right?
34:53You're you're you're duplicating 5, 10,
34:5515, 20 employees. Is that possible? Yes.
34:58And I'll explain you how that works.
35:01Because if your work is scoped well,
35:03Claude could actually move forward a few
35:05things at the same time. In cloud
35:08desktop, basically the code tab can run
35:11separate sessions. So each session could
35:14have its own context and its own set of
35:16changes and and with work tree
35:19isolation, those changes can stay
35:21separate instead of all getting mixed
35:23together. So the simple way to think
35:25about it is this. Each session should
35:29feel like you're handed one clear
35:31assignment to one person. So imagine you
35:36know you sit in sit down in the morning
35:38and you want three things to be moved
35:40forward. The first thing is technical.
35:43So maybe the onboarding redirect is
35:45broken after email verification and you
35:48need someone to figure out figure it out
35:50and just fix it. The second thing is
35:54product clarity. The landing page hero
35:56is maybe too vague. Um and you want the
35:59med spa med spa owner to understand the
36:01value in the first 5 seconds. And the
36:04last thing is sales. Um maybe you've got
36:07a bunch of customer notes and you want
36:09to turn them into a sharper demo script.
36:11Um those are all really different jobs,
36:13right? Um one is debugging, one is
36:15product and copy, one is sales
36:17enablement.
36:20Um in the old workflow, I would probably
36:23do those one after the other. Um, in the
36:26AI employee workflow, I can give each
36:30one its own cloud session and with the
36:32same product context, and a very clear
36:36output. So, the bug session uh fix
36:40should come back with the root caused,
36:42the files it changed, the checks it ran,
36:45and what I should look for in the diff.
36:48the landing page session. Well, that
36:50should come back with a before and after
36:52hero, the customer language it used, and
36:54what changed in the preview and why the
36:57new version is clearer. And the demo
36:59session, um, well, that should have
37:02pulled the customer notes, the objection
37:04it was trying to handle, and what I
37:06should review before recording. So, the
37:10unlock here is this. You don't want a
37:12gile a giant pile of AI work at the end
37:15of the day that you have to untangle
37:17because that's not fun. You basically
37:19want, you know, little packets of work
37:21that the human being could you can
37:24inspect, accept, revise, or reject. So,
37:29okay, let's let's what does this mean in
37:31practice? How can we actually do this? I
37:33would use a prompt like this.
37:36So, I would say work on the onboarding
37:38redirect bug after email verification.
37:41Use the project context files before you
37:43propose a fix. Start by explaining what
37:46you think is causing the bug and which
37:47files you need to inspect. After I prove
37:50the plan, implement the smallest clean
37:52fix. And when you're done, give me the
37:53root cause, the files you changed, the
37:55checks or tests you ran, what you should
37:57review in the diff, and anything
37:59anything that feels uncertain.
38:03Now for the landing page uh hero, you
38:07can do a similar format of the prompt
38:10and you can just say improve the landing
38:12page hero so a med spot owner
38:14understands a value in 5 seconds. Use
38:16claw.md roadmap md review.md and the
38:20latest customer notes. Important to
38:22include that there. Keep the change
38:24focus on the hero section unless a small
38:27supporting change is necessary. And when
38:29you're done, give me the before and
38:30after, etc., etc.
38:32And lastly, for the sales bit, I would
38:35say a similar type prompt. I'd say,
38:36"Read the latest customer notes and turn
38:38them into a short demo script for the
38:40mislead responder. Use the customer's
38:43actual language where possible. The demo
38:46should show pain, the product moment,
38:48and the payoff. And when you're done,
38:49give me the demo script, etc., etc." So,
38:53what have I done here? I gave each
38:55session a clear job, the same project
38:58context, and a specific handoff. The
39:01point is not to have AI spray work in
39:03every direction. The point is you wake
39:05up, you pick the three most useful work
39:08uh work streams, you have Claude move
39:10each one forward in a way that you can
39:12actually review. The eighth piece is
39:15permission. We've got one more piece
39:17after this. So permissions are really
39:20important because this is risky
39:22business. I think about permissions the
39:25same way I think about delegation.
39:27There's some things that cloud can do
39:28freely. There's some things that cloud
39:30should ask about. Um, some things they
39:33got to stay with the human. So, let's
39:35talk about safe actions, ask first
39:38actions, and human own actions. So, safe
39:42actions are things like reading files,
39:44inspecting code bases, proposing plans,
39:47running local tests, edit a small
39:50feature branch, update docs, create a
39:53draft pull request.
39:56Ask first actions are things like
39:58installing dependencies, changing
40:00database migrations, touching
40:02authentication,
40:04uh changing payment logic, deleting
40:06files, things like that. And then
40:09humanowned actions are production
40:12deploys, uh customer data uh decisions,
40:15uh billing decisions, um security
40:18sensitive changes, like you still want
40:20that to be a human beingled.
40:23Even if you do have AI employees, that
40:26high-risisk stuff, you still want to be
40:29with human beings. In cloud desktop, you
40:33can actually choose permission modes
40:34depending on how much control you want.
40:37So you can start conservative and then
40:39you can use plan mode for the bigger
40:41changes and you can use manual review
40:43when you're learning the system. So, I
40:46would let Claude move faster as the repo
40:49brain, the review checklist and task
40:51scopes get stronger and stronger. That's
40:53the management model. You give the AI
40:56room to work and boundaries. Um, and I
41:00wish more people did that. You know,
41:02going yolo mode. Um, it's it's a bit too
41:06risky. Um, so thinking about permissions
41:09as a strategy is going to be helpful to
41:11actually be able to scale your team of
41:14AI employees. The ninth piece to
41:17understand is skills, connectors, and
41:19hooks. This is our last piece. Um, this
41:21is the part where cloud code stops
41:24feeling like this generic thing and it
41:27starts feeling like it belongs to your
41:29company. So, I'm sure you've heard of
41:31skills. What is a skill? It's basically
41:33a repeatable way of doing work. If you
41:36find yourself typing the same prompt
41:39over and over again, chances are that
41:41should just be a skill. So, for example,
41:44in this Med Spa project I was working
41:45on, I would make the landing page tear
41:48down a skill. And every time I use it,
41:51Claude should look at that page like a
41:53med spa owner and check that 5-second
41:56clarity, find that vague copy, and look
41:58for the missing trust signals, inspect
42:00the CTA, and suggest one focus
42:03improvement. I'd also make something
42:05like a customer notes skill. You know,
42:07it' read latest calls or support notes
42:09and pull out the exact words that
42:11customer use customers use, the repeated
42:15objections and the buy buying triggers
42:18um that keep showing up. That's super
42:20super useful because now Claude isn't
42:22just building from my opinion, right?
42:24It's building from customer language.
42:26And this is a whole trend that I'm
42:28seeing more happen more and more and it
42:30just makes sense that you'd use that.
42:32You can also use that same skill when
42:34you're uh creating copy for ads.
42:38I would also do a uh demo script skill.
42:42So I would take the latest product state
42:44and customer notes and turn them into a
42:46short demo. You know, here's the pain,
42:48here's the product moment, and here's
42:50the payoff. That's the type of thing
42:52that's going to save you hours every
42:53single week. There are places you can
42:56download skills um or you can just you
43:00know create the skills yourself.
43:04If people are interested I can do a deep
43:06dive on different marketplaces for
43:08skills and how to explore them. Let me
43:10know in the comment section. So what is
43:13a connector? Well the connector gives
43:15Claude just better context. So you know
43:19it gives it access to GitHub. It gives
43:21it access to linear if you use that,
43:24access to Google Drive, Slack. It's
43:26basically just a plugin that allows you
43:28to, you know, access all these different
43:32tools. And what's a hook? A hook are the
43:35guard rails around the work. So after
43:38Claude edits code, run formatting. You
43:41know, before a PR summary, run tests.
43:44Before a change ships, run checks that
43:47matter. So you've got skills that make
43:49the work repeatable. You've got
43:51connectors that give Claude better
43:52context and now you've got hooks that
43:55make the workflow safer. And when you
43:58combine all those with your road map,
44:00your review standards, your customer
44:02notes, and your routine, Claude just
44:04becomes a lot more bespoke for your
44:07company. And that's kind of the bigger
44:09point with with uh with all these
44:11things. These are like powerups for your
44:15business. And you you can imagine that
44:18this is kind this is creating a kind of
44:20moat you know if you have a really good
44:22system around this it's creating a moat
44:24because you're going to get really good
44:25outputs
44:26uh from your cloud code. Okay. So by now
44:29I hope you understand like the main
44:31components of using cloud code to make
44:34it an AI employee. But you might be
44:37thinking to yourself like okay how can I
44:39actually make a plan to try this? Well,
44:43here's a 7-day plan that I would give to
44:45someone who wants to create a digital AI
44:49employee. So, the on day one, and by the
44:52way, you could do this in 7 hours, you
44:55can do it in 70 minutes, you can do it
44:56in 7 days, you could do it in 31 days.
44:59Um, it depends how technical you are,
45:01how much time you have, are you working
45:03a job? Um, but you know, I thought it
45:06would be fun to just think about it from
45:07a week perspective. So on day one,
45:11create the repo brain. You know, create
45:12the cloud MD, the roadmap MD, the review
45:15MD, the SLcontext, the SLC customers,
45:17all that stuff. You write the customer,
45:19the problem, the current goal, and the
45:21definition, the definition of done. On
45:24day two, you can run the plan mode. So
45:26you can pick one small product task and
45:28make Claude inspect the repo before
45:31editing. Uh, your output is a plan, your
45:35output is a file list, your output is
45:37risks, your output is verification
45:39steps. On day three, just build one
45:42visible improvement. The weightless
45:44form, the pricing page, the demo flow,
45:47the onboarding bug, choose something
45:49small enough to review and real enough
45:52to show a real customer. On day four,
45:56use the preview loop. Have Claude open
45:58the app in desktop preview. Click
46:00through the flow. Check mobile and
46:02improve clarity. On day five, review the
46:05work, open the diff view, read the
46:08before and after changes. Ask Claude to
46:10review against review.mmd and and use
46:13the review code flow for a serious
46:15change that you might do. On day six,
46:17you can actually send it to 10 people.
46:18Send the loom, the demo, the landing
46:21page, whatever it is you end up building
46:23to some some people who might care. Then
46:26put their replies into that slashc
46:28customer repo. And then on day seven,
46:32create the first routine. Start with the
46:34morning brief. Let Claude read the
46:36customer notes and issues. Then
46:38recommend one useful build task. Now you
46:41have this loop. It's alive. It's
46:43breathing. And you're starting each day
46:45with context, feedback, and a next move.
46:48And it's basically an AI employee,
46:51right? It's an AI employee because the
46:53final loop looks like this. The customer
46:56feedback goes into slashc customers. The
46:59product direction goes into roadmap.mmd.
47:02The working style goes into claw.md. The
47:05quality standards go into review.md.
47:08Small tasks go through plan mode.
47:11Changes go through preview and review.
47:14Recurring work becomes a scheduled
47:16routine. And that's the 247 cloud code
47:19employee setup. Once you see it this
47:22way, it you know cloud code doesn't feel
47:24like a chat box anymore. The product,
47:27the customer feedback, the docs, the
47:29demos, the reviews, the recurring work
47:31all start and they live in this
47:33operating loop that over time you have
47:35to optimize, right? It's not going to be
47:36perfect. Um, but once you start building
47:40like this, you're not going to build
47:41like the old way. in the in the show
47:44notes in the description, I'm going to
47:46include all the prompts that I went
47:47through so you can learn from them, so
47:49you can copy this workflow so you can
47:51too spin up your AI employees using
47:54cloud code. I think that the leverage
47:56you get from spinning up AI employees
47:58right now is insane. Uh you can use
48:01cloud code, you can use other systems,
48:02but you know, do it. Have fun, get your
48:05hands dirty, and I'll see you next time.
48:08Have a creative day.

About this transcript

This page contains the full transcript of Claude Code New Features, Explained by Greg Isenberg, generated from the public captions YouTube serves with the video. The transcript has 8,225 words across 1,178 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to translate the transcript into 100+ languages.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, translation to 100+ languages, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.