Claude Code Full Course 2026 | How Senior Engineers Actually Build with AI — Transcript
Full transcript
- 0:00This is Claude code refusing to read my
- 0:03environment file because I told it that
- 0:06it's never allowed to. This is it laying
- 0:09out its entire database plan and waiting
- 0:12for my approval before it writes a
- 0:15single line of code. And this is it
- 0:18splitting one big investigation across
- 0:21five parallel agents because I asked it
- 0:24to. If your entire Claude code
- 0:26experience so far is typing something
- 0:28like build this feature and then hitting
- 0:30enter, you're using maybe 10% of what
- 0:34this tool allows you to do. So,
- 0:36let me ask you this. Do you really know
- 0:40when to use skills, sub agents, project
- 0:43rules, plan mode, permissions, and all
- 0:46the other parts of Claude code that
- 0:48decide how your agent actually works?
- 0:52Because if your answer to some of these
- 0:54is no,
- 0:55then yes, there is still quite a lot to
- 0:58learn. And companies are already paying
- 1:01engineers $200,000
- 1:04a year to build AI agents, orchestration
- 1:08systems, and production workflows. Not
- 1:10because these engineers can type build
- 1:13this feature into a prompt any better
- 1:14than you can, because knowing how to
- 1:17work with an agent while building a real
- 1:20software is a completely different skill
- 1:23from just getting one to generate code.
- 1:25And that's the skill this video is
- 1:27about.
- 1:28Hi there and welcome to this Claude code
- 1:31crash course where I'm going to spend
- 1:33the next few hours showing you random
- 1:35commands one after another and expecting
- 1:38you to remember all of them.
- 1:40Oh, wait.
- 1:42Wrong script. Instead, you're going to
- 1:44learn Claude code by actually using it
- 1:47on a real app. Throughout this course,
- 1:49we'll work on an e-commerce app inspired
- 1:52by a real luxury storefront. But here's
- 1:55the important part. Every feature we
- 1:57build exists for one reason.
- 2:00It's the moment a Claude Code concept
- 2:03actually becomes useful. A design system
- 2:07when you learn how permissions work. A
- 2:09real Postgres database when you learn
- 2:11why the plan mode exists. Reusable
- 2:14workflows when you notice the same
- 2:16process repeating.
- 2:18Separate agents when the code base gets
- 2:20big enough that one context can't carry
- 2:23everything. And if you've been on this
- 2:25channel a while, you know I love a long
- 2:28build. This isn't that. This video is
- 2:32optimized for one thing. That you walk
- 2:35away actually understanding how to work
- 2:38with an AI coding agent in a couple of
- 2:40hours and not a couple of weekends.
- 2:43So, along the way, you'll learn how
- 2:46Claude works inside your code base. How
- 2:48to give it persistent project context
- 2:50with Claude and agent.md file. How
- 2:53permissions control what it can access.
- 2:56When plan mode is actually worth it.
- 2:59How skills turn processes you keep
- 3:01repeating into reusable workflows.
- 3:04And how sub agents let Claude hand over
- 3:08focused work to another agent without
- 3:11filling your main context with
- 3:13everything else it had to read along the
- 3:15way. The goal isn't that you know 50
- 3:18Claude Code commands by the end.
- 3:20The goal is that you understand how to
- 3:22work with a coding agent and know
- 3:24exactly when and why to reach for any of
- 3:27these. Because pretty soon, simply
- 3:30saying I use AI to code isn't going to
- 3:34mean very much.
- 3:35Almost everyone will. What will matter
- 3:38is how well you work with it. And to
- 3:41make it even easier, you don't need to
- 3:43memorize anything in this video.
- 3:45I've created a completely free Claude
- 3:47Code cheat sheet with the commands
- 3:49you'll actually to coming back to, such
- 3:51as sessions, context management,
- 3:53permissions, models, plan mode, skills.
- 3:56All of it is there.
- 3:57So, you can just grab it from the link
- 3:59in the description and keep it open
- 4:00beside you instead of trying to remember
- 4:03everything. Oh, and one more thing
- 4:05before we start. Everything in this
- 4:06crash course scales up into a complete
- 4:09engineering workflow that I've built and
- 4:12open-sourced for free. And there's a
- 4:13full agentic engineering course if you
- 4:16ever want to go deeper. We've been
- 4:17testing it with a close group of
- 4:19engineers who went through the full
- 4:20course and loved it.
- 4:22And as of today, it is officially
- 4:24public.
- 4:25I'll leave the link down in the
- 4:26description. And with it, you'll also
- 4:28get a discount on top of the current
- 4:30offer.
- 4:31Preparing for that course for the past 2
- 4:33years built the foundation that I'm
- 4:36going to use right now to teach you the
- 4:37Claude code skills in this video. So,
- 4:40for now, we'll proceed with that, but if
- 4:42at any point in time you want to go
- 4:43deeper,
- 4:44you know where to find it. But, that's
- 4:46all I'll say about it for now. So, let's
- 4:48get into Claude code.
- 5:00So, what is Claude code?
- 5:03You can already open Claude, ask it
- 5:05coding questions, give it files, and
- 5:08build things with it.
- 5:09So, you might be thinking,
- 5:11"Why do you need Claude code?"
- 5:14Well, Claude code can work directly
- 5:16inside your development environment.
- 5:18You open your project, run Claude code,
- 5:22and it can read files, search through
- 5:24your code base, edit code, run terminal
- 5:27commands, use Git, run tests, and check
- 5:30whether its own changes actually worked.
- 5:33Imagine you're building the e-commerce
- 5:35app in this course, and customers can
- 5:37add more units to their cart than you
- 5:40actually have in stock. Instead of
- 5:42finding the cart logic yourself, copying
- 5:46it into Claude and explaining everything
- 5:48around it, you could simply say,
- 5:50"Customers can add more units to their
- 5:52cart than what we have in stock."
- 5:55Find out why and fix it.
- 5:58Claude can then search for the cart
- 6:00logic, inspect both your product and
- 6:03inventory code, follow the flow, make
- 6:05the necessary change, and then run the
- 6:08tests. That's what makes Claude Code an
- 6:11agentic coding tool.
- 6:13The Claude model is still doing the
- 6:16reasoning underneath,
- 6:17but Claude Code gives that model the
- 6:20tools, project context, and environment
- 6:23it needs to actually work on your code.
- 6:27That's the important difference. So,
- 6:29wait, does it mean that Claude can see
- 6:32my private code?
- 6:34Yes, Claude Code can read files inside
- 6:37your project you've given it access to.
- 6:40It searches your project locally rather
- 6:42than first uploading and then indexing
- 6:45the entire repository somewhere else.
- 6:48But, when Claude needs the contents of a
- 6:50file to reason about your task, relevant
- 6:53information can still be sent to the
- 6:55Claude model. So, Claude Code runs
- 6:58locally does not mean that everything
- 7:01always stays in my machine. If you're
- 7:03working with private company code,
- 7:06understand the data policy of the
- 7:07account you're using, and follow
- 7:09whatever rules your company has around
- 7:11AI tools. And then, there's the obvious
- 7:14next question. What about the .env?
- 7:17Later on in this course, our e-commerce
- 7:19app will contain a .env files with
- 7:22things like a database URL, a better
- 7:25auth secret, or even a Stripe secret
- 7:28key. You shouldn't assume that Claude
- 7:30automatically knows those values are
- 7:32sensitive and should never touch them.
- 7:35Claude Code has a permission system
- 7:37where you can explicitly control what it
- 7:40can read, edit, or execute.
- 7:43You can block files such as the .env or
- 7:47.env.anything,
- 7:49secrets, or any kind of credentials, and
- 7:52therefore control which tools Claude is
- 7:55allowed to use. I'll show you how you
- 7:57can set this up properly later in the
- 7:59course. And we'll actually test it by
- 8:02blocking an environment file, asking
- 8:04Claude to read it, and checking whether
- 8:06that access is refused. For now, just
- 8:10remember that sensitive files should be
- 8:12explicitly protected. Okay. Now, let's
- 8:16talk about how Claude code actually
- 8:18works.
- 8:20Now that Claude can work directly inside
- 8:23your project, how does it decide what to
- 8:26do? Most tasks follow a simple loop.
- 8:29Gather context, take action, and then
- 8:32verify the result.
- 8:34So, imagine one of your inventory tests
- 8:36starts failing.
- 8:38You ask, "Find out why the inventory
- 8:40test is failing and fix it."
- 8:43Claude might first run the test,
- 8:46then read the error, then search for the
- 8:48inventory logic, then inspect the
- 8:50relevant files, then make a change, and
- 8:53then run the test again. And if it still
- 8:55fails, Claude gets new information from
- 8:58that result and continues. That's the
- 9:01basic example of an agentic loop.
- 9:04And while this is happening, you'll
- 9:06actually see the tools that Claude is
- 9:08using. Read when it opens a file,
- 9:11glob when it's looking for files
- 9:14matching a pattern,
- 9:15grep when it's searching through the
- 9:17file contents,
- 9:18edit when it's changing an existing
- 9:20file, write when it's creating a file,
- 9:24and bash when it's running something in
- 9:26your terminal, such as pnpm build, test,
- 9:29or git status.
- 9:30And if Claude needs information from
- 9:33outside your project, you may see web
- 9:35search and web fetch.
- 9:38Later, for example, Claude might use the
- 9:41web to check the current drizzle
- 9:42documentation or research a design
- 9:44reference for the storefront. So, don't
- 9:47only read Claude's final answer.
- 9:50Watch what it's doing. If you see it
- 9:52reading your product schema while
- 9:54debugging stock, you know what it's
- 9:56investigating.
- 9:58And if you see tests running through
- 9:59bash, you know it's verifying its work.
- 10:02And if you see web search,
- 10:04it looks like Claude decided it needed
- 10:05information from outside the project,
- 10:08maybe from Stack Overflow, who knows.
- 10:10And you can totally interrupt Claude
- 10:12while it's working. If it makes a wrong
- 10:15assumption or starts heading somewhere
- 10:17else you don't want, correct it instead
- 10:19of waiting for the entire task to
- 10:20finish. You can do that by simply
- 10:22pressing the escape key. Now, what can
- 10:25Claude code do by default?
- 10:27Before you add any skills, MCP servers,
- 10:30sub agents, or anything more advanced,
- 10:33Claude code can already do you a lot.
- 10:36It can read, create, and edit files,
- 10:39search through your code base, run shell
- 10:41commands, start servers, run tests, work
- 10:44with Git, search the web, fetch
- 10:46documentation, and use the supported
- 10:48code intelligence, such as errors,
- 10:51definitions, and references. That's
- 10:53already enough to build a large part of
- 10:56the e-commerce app in this course.
- 10:58And you'll learn each of these in more
- 11:00detail as they start helping you build
- 11:02faster. So,
- 11:04let's install it. Claude code is
- 11:06available in several places, including
- 11:08the terminals, IDEs, desktop, and the
- 11:11web. For this course, I'll start mostly
- 11:14from the terminal because it makes it
- 11:16very easy to see what Claude is actually
- 11:18doing. So, head over to Claude code
- 11:21website and follow the instructions for
- 11:23your operating system. Once you install
- 11:25it, you can verify it by running Claude
- 11:28{dash} {dash} version.
- 11:30And if you'd rather work inside an
- 11:32editor, Claude Code is also available
- 11:34through supported IDE integrations such
- 11:37as VS Code, and you can use it through
- 11:39compatible editors like Cursor as well.
- 11:42Once we check it out in the terminal, I
- 11:44would highly recommend that you also
- 11:45download Claude Code as a VS Code
- 11:48extension and then check it out there.
- 11:50It has a bit of a friendlier UI. And as
- 11:53I said, there are also web, desktop, and
- 11:56even remote ways to use Claude Code such
- 11:58as from your phone. But you don't need
- 12:00to learn every option right now.
- 12:02Either way, the core workflow is the
- 12:05same and we'll use other surfaces later
- 12:07on when they actually become useful.
- 12:10Another important question is how do you
- 12:12access Claude Code? Well, the exact
- 12:15plans and usage limits can change over
- 12:18time, so understand what they offer and
- 12:20see what's enough for you.
- 12:22You can use Claude Code through
- 12:24supported Claude subscription plans.
- 12:26There's even team or organization plans
- 12:29or through API-based billing through the
- 12:31Claude console.
- 12:33If you're learning and building normal
- 12:35projects, a subscription will give you
- 12:37predictable usage, so definitely start
- 12:39there. And if you're using Claude Code
- 12:41heavily every day on bigger projects or
- 12:44longer sessions, you'll naturally need a
- 12:46higher tier.
- 12:48And API billing charges per token
- 12:51instead of a subscription allowance.
- 12:53That's usually the right choice for
- 12:55automation and CI pipelines, not for
- 12:57following a course because heavy
- 12:59interactive sessions add up quickly when
- 13:02you're paying per token. And that's
- 13:04really all you need to know for this
- 13:05course. Check out Anthropic's current
- 13:07pricing page whenever you're choosing a
- 13:09plan because details can change.
- 13:12So now, let's actually use Claude Code.
- 13:15Create an empty folder on your desktop,
- 13:17MKDIR,
- 13:19and call it Atelier Store. We're going
- 13:22to build an e-commerce store for a
- 13:24luxury brand like Gucci, for example.
- 13:27So, create it and then see the over into
- 13:30it. Once you do, we can actually open
- 13:32that folder up within VS Code. And we're
- 13:35in. Then, we can start Claude Code.
- 13:39I will open up my terminal and expand
- 13:41it, and then within it, simply run
- 13:44Claude.
- 13:45The first time you use it, you'll be
- 13:47asked to sign in.
- 13:49So, sign in. And then, you'll be asked
- 13:51whether you trust this folder.
- 13:54I'll say yes, we trust it.
- 13:56And then, you're in.
- 13:58When you take a first look at it, it
- 14:00seems like there's a lot of stuff
- 14:01happening right here.
- 14:03If this looks daunting,
- 14:05I would highly recommend hitting over to
- 14:07extensions
- 14:08and then search for Claude Code.
- 14:11I can even update it right here. It's a
- 14:13super popular Visual Studio Code
- 14:15extension
- 14:17that you can open up by simply pressing
- 14:19command shift P
- 14:20and searching for Claude Code.
- 14:23It'll open up that same session that we
- 14:25saw right here as part of our UI. And as
- 14:29you can see, we need to be logged in, so
- 14:31we can log in either through our
- 14:32subscription or through the Entropic
- 14:34console.
- 14:36In this case, most likely, you have an
- 14:38active subscription, so let's go with
- 14:40that. It'll open up a new browser
- 14:41window, so simply continue with
- 14:43whichever provider you chose.
- 14:45And then, you're in.
- 14:47As you can see here, you can see the
- 14:49model you're using.
- 14:51You can see the permissions and modes,
- 14:53such as whether you're in auto, plan,
- 14:55edit automatically, and so on. And you
- 14:57can also upload some files or run some
- 15:00additional commands.
- 15:02Anything that you can do within
- 15:03terminal, you can also do right here
- 15:05using the Claude Code VS Code extension.
- 15:08So, from this point onward, whether
- 15:10you're following along through a
- 15:11terminal or through the extension,
- 15:13either way works. I might even switch
- 15:16between the two.
- 15:17Now, here it says not logged in, but we
- 15:20just logged in through our extension, so
- 15:22if I just rerun Claude, it should be
- 15:24able to get access to our account. And
- 15:27we're in.
- 15:28Here, you can see which model we're
- 15:30using, and which effort is currently
- 15:32selected. Here, you can see some tips on
- 15:35how we can switch the model anytime by
- 15:37running the model command, and then
- 15:39switching between different models. At
- 15:41the bottom, you can also see which model
- 15:42you're using, how much of the context
- 15:44you have spent, and on which mode you're
- 15:46on. You can hold the shift tab to cycle
- 15:48between different modes. But yeah, let's
- 15:50give Claude the first real task.
- 15:54Let's tell it to set up a new Next.js
- 15:58e-commerce app in this folder using
- 16:02TypeScript,
- 16:04Tailwind,
- 16:05Better Auth,
- 16:07Drizzle ORM, and Postgres via Neon. I'll
- 16:11hold the shift key to be able to enter a
- 16:13couple of empty spaces, and tell it to
- 16:16only create the initial project
- 16:19structure, dependencies,
- 16:22configuration, .env example, and minimal
- 16:26integrations.
- 16:28I'll tell it very clearly, do not build
- 16:32e-commerce features, full auth flows,
- 16:36schemas, UI, payments, or deployment.
- 16:40That's going to come in later.
- 16:43So yeah, this is going to be our first
- 16:45prompt.
- 16:46So, just press enter and watch what
- 16:50Claude does. You'll probably see a lot
- 16:52of different commands like bash, write,
- 16:55read, and edit as it creates the
- 16:57project, installs packages, and checks
- 17:00its work. This is the agentic loop that
- 17:03you just learned about happening on the
- 17:06actual app you're going to be building
- 17:08throughout this course. If you want to,
- 17:10you can also expand specific pieces, and
- 17:13you can see that here it used the bash
- 17:14command to run something. Then, it's
- 17:17installing off and DB dependencies. So,
- 17:20let's give it some time until it
- 17:22finishes running this command. And in
- 17:24less than 2 and 1/2 minutes, it is done.
- 17:28It's scaffolded the project, verified
- 17:30it, and gave us info on the text stack
- 17:32it used, as well as the files it
- 17:34created.
- 17:35So, what you just saw right here was
- 17:38running Claude code interactively. You
- 17:41can stop the current session by pressing
- 17:43control C two times.
- 17:45And if you run Claude, like we just ran
- 17:48it right now, opens a new session that
- 17:50stays active.
- 17:52You give Claude a task, it works, you
- 17:55respond, and the conversation continues.
- 17:58But, you can also start Claude with the
- 18:00first task already included.
- 18:02You can do something like this.
- 18:04Claude, explain how this project is
- 18:07structured. That'll start the session,
- 18:10and then automatically prompt the agent
- 18:12to give you the answer.
- 18:13And there you go. The answer is in. But,
- 18:16in this way, the session will remain
- 18:18active. So, you can continue speaking
- 18:21with the agent. But, if you just want to
- 18:23ask it something, and then call it a
- 18:25day,
- 18:26there's also a one-off mode,
- 18:30where Claude performs a task, prints the
- 18:33results, and then exits. You can use it
- 18:35that way by adding the P tag, and then
- 18:38asking it a specific question. If you do
- 18:41that,
- 18:43Claude will perform the task, print out
- 18:45the result, and then exit.
- 18:48There you go.
- 18:49Back in the terminal. But, you can even
- 18:51pipe something into it,
- 18:53like this.
- 18:55Tail N 200 app logs, Claude P find
- 19:00anything unusual in these logs. So, if
- 19:02there were some logs, it will be able to
- 19:05go through it and share its output
- 19:07directly into the terminal. This becomes
- 19:09very useful later on for automation and
- 19:12CI.
- 19:14For now, just remember that Claude keeps
- 19:17the session open and Claude {dash} P
- 19:20runs one task and then exits. Then, the
- 19:23next major question is which model
- 19:26should you be using?
- 19:28So, if you're within the Claude window
- 19:30and you type {forward slash} model, you
- 19:33can see which models are currently
- 19:35available.
- 19:36The exact model names will change over
- 19:38time, so don't memorize the list from
- 19:41this video. Instead, think about them in
- 19:44terms of the task. Use a faster,
- 19:46general-purpose model for normal
- 19:48development, small fixes, and everyday
- 19:51coding. Use a stronger reasoning model
- 19:54when you're dealing with things like
- 19:55architecture, difficult debugging,
- 19:58larger refactors, or several systems
- 20:01integrating at once.
- 20:02For example, changing the layout of a
- 20:04product card probably doesn't need your
- 20:07strongest model. Figuring out how the
- 20:09inventory should behave across the
- 20:11database, storefront, and checkout,
- 20:13well, that might need a stronger one.
- 20:16So, yeah, whenever you want to switch
- 20:18the model, you can simply use the
- 20:19{forward slash} model command. But,
- 20:22yeah, that's enough for now. You'll
- 20:24understand the model choices much better
- 20:26once you actually start working on the
- 20:28harder parts of our e-commerce app. And
- 20:31other than that, you don't need to know
- 20:3350 other commands. I will show you some
- 20:36of the more important ones, but don't
- 20:38try to remember all of them.
- 20:40That's exactly why I included that free
- 20:42cheat sheet in the description down
- 20:44below, so you can open it up, have it
- 20:46side by side. Whenever you need
- 20:48something, you know where it is. And
- 20:50with time, you'll naturally remember it.
- 20:52So, you can start Claude like this.
- 20:56You can start Claude with a task, as you
- 20:58know. You can run one task and then exit
- 21:02by using the {dash} P command.
- 21:05You can also continue from your most
- 21:08recent session by running Claude-c.
- 21:12You can also resume an older session by
- 21:15running Claude-r, and then you can
- 21:17select which session you want to run.
- 21:19You can see which other commands are
- 21:21available by running Claude, and then
- 21:23within it, you can run help. Here, you
- 21:25can see all the information. And one
- 21:28more, which is super important, is
- 21:31forward-slash clear. But, the question
- 21:33is, when should you use clear to start a
- 21:36new session with an empty context? Well,
- 21:39suppose that later on, you spend half an
- 21:41hour debugging some authentication
- 21:44connection.
- 21:45Claude has read your auth code, seen
- 21:48several errors, and tried a few
- 21:50different approaches. Then, you suddenly
- 21:52say, "Redesign the product cards."
- 21:55Claude is still carrying all that
- 21:57authentication conversation in the
- 21:58current session. So, that information
- 22:01probably isn't helping with the product
- 22:03card task. That's when running clear is
- 22:06useful,
- 22:07as it gives you a fresh conversation.
- 22:10You don't need to use it after every
- 22:11task. Use it when you're moving onto
- 22:14something genuinely unrelated.
- 22:17You'll learn more about context
- 22:18compaction and sub-agents later on.
- 22:22Or, if you want to dive deeper, you can
- 22:23check out the Agentic Engineering
- 22:25course. I believe that under the third
- 22:27module, I'm covering a lot of stuff
- 22:30regarding your agents, like what the
- 22:32agent sees, how they read your code
- 22:34base, context windows, context rod,
- 22:37topic switching, clearing versus
- 22:38compacting, and much more.
- 22:41But, yeah. Now that the initial setup is
- 22:43finished, you can simply ask the agent
- 22:45to explain the code base,
- 22:48such as the architecture, technologies,
- 22:50the main folders, and important parts
- 22:52currently connect. Now, if you watch
- 22:54Claude again, you'll probably see it use
- 22:57bash, glob, or grep, as it searches
- 23:00through the project and builds an
- 23:02The point isn't only to read the final
- 23:04explanation.
- 23:06Pay attention to how Claude finds the
- 23:09answer. That's one of the most useful
- 23:11habits you can build while learning
- 23:13Claude code. You should understand what
- 23:15Claude code is doing even when Claude is
- 23:17doing most of the actual file and
- 23:20command work for you. But with this,
- 23:22another problem appears immediately.
- 23:25As the app grows, you don't want to keep
- 23:27telling Claude some specific rules, like
- 23:30use pnpm or we're using Drizzle.
- 23:35Or this is how tests should run. Or to
- 23:39keep the design consistent, Claude needs
- 23:42a way to know those project instructions
- 23:45every time you start a new session.
- 23:47And that's exactly where the claude.md
- 23:52or as of super recently agents.md, which
- 23:56now Claude code is reading as well,
- 23:58comes in. So, let's cover those in the
- 24:00next lesson.
- 24:03Now that you've got your store project
- 24:05running, what happens when you close
- 24:08Claude code and then come back tomorrow?
- 24:11Claude won't automatically remember that
- 24:14you're using pnpm, how you're using
- 24:16Drizzle or RAM to define your Postgres
- 24:18schemas, or that same mistake that you
- 24:21already corrected twice.
- 24:23You don't want to keep explaining the
- 24:25same project every time you start a new
- 24:28session.
- 24:29And that's exactly where the claude.md
- 24:32or the agents.md file comes in.
- 24:34Claude.md is simply a markdown file
- 24:37where you give Claude instructions about
- 24:39your project.
- 24:41Claude loads it automatically when a
- 24:43session starts, so those instructions
- 24:45are already there before you even give
- 24:47it your first task. For example, use
- 24:50pnpm instead of npm. Use Drizzle for
- 24:54database access. Or run pnpm type check
- 24:57before finishing larger changes.
- 25:00Instead of repeating those things again
- 25:02and again, you put them in a Claude MD.
- 25:05Then, whenever Claude works on this
- 25:07project, it already knows them.
- 25:09And as of recently, it is official.
- 25:13Claude is finally adding support for
- 25:15agents MD to Claude code. Starting today
- 25:18in the newest version, if there is no
- 25:21Claude MD in a folder, Claude will check
- 25:24for and use the agents MD file. So,
- 25:27whenever I mention anything about the
- 25:29Claude MD, the same rules go for the
- 25:32agents MD file. This agents MD file has
- 25:35been the standard for all other coding
- 25:37tools, and it looks like Claude code is
- 25:39catching up, too. But, there's one thing
- 25:42you need to understand. Claude MD gives
- 25:44Claude instructions. It doesn't
- 25:47technically block Claude from doing
- 25:49something.
- 25:50So, if you write never modify migration
- 25:53files manually,
- 25:54Claude should follow that rule. But, it
- 25:57still technically has access to those
- 26:00files. If something absolutely shouldn't
- 26:02happen, that's where permissions,
- 26:05sandboxing, and hooks come in. And we'll
- 26:08get to those next.
- 26:10But, before going further, you should
- 26:12understand the context window.
- 26:15This is basically the information Claude
- 26:18is working with during the current
- 26:20session.
- 26:21That includes your conversation, files
- 26:24that Claude has read, terminal output,
- 26:27tool results, Claude MD file, and all
- 26:30the other memory Claude has loaded.
- 26:33And that context has a limit.
- 26:35So, if you keep loading unnecessary
- 26:38information into it, you're using space
- 26:40and attention that Claude could be using
- 26:43on the actual task. And that's also why
- 26:46Claude MD shouldn't become some massive
- 26:49document. As more information enters the
- 26:53context window, Claude has more things
- 26:55competing for its attention.
- 26:57You can think of it like an attention
- 26:59budget.
- 27:00Every line inside the Claude or Agent MD
- 27:03files is using some of that budget
- 27:06because Claude keeps loading that file
- 27:08while working on your project. So, don't
- 27:10put something there just because Claude
- 27:12might need to use it one day. Put things
- 27:14there because Claude should know them
- 27:16whenever it works on the project. And
- 27:19you'll often see the guidance around
- 27:20keeping Claude MD well under 200 lines,
- 27:23but don't treat 200 lines as a target.
- 27:26If everything useful fits into 30 or 40
- 27:29lines, that's even better. And talking
- 27:32about the context budget, in one of the
- 27:34lessons in the course, I go over
- 27:36something that even I didn't know before
- 27:38I started working on it. And that's
- 27:40context rot.
- 27:42I mean, I knew about the concept of
- 27:44context rot. You shouldn't fill up your
- 27:46context window because agent's
- 27:48performance drops significantly, but I
- 27:50didn't know it was this severe.
- 27:53Don't wait until the window is nearly
- 27:56full because a model advertising 200,000
- 27:59token window can show real, measurable
- 28:02degradation starting at 50,000 tokens,
- 28:06which is only a quarter in.
- 28:08So, the number on the box is the
- 28:10technical ceiling, but it is not the
- 28:12point where the quality starts to slip.
- 28:16So, as a rule of thumb, context rot
- 28:18isn't something that happens near the
- 28:19edge of a full window. It starts well
- 28:22before that, continuously, not as a
- 28:24cliff. So, whenever you start working on
- 28:26something new, clear the context. Now,
- 28:29let's talk about where does the Claude
- 28:31MD or Agent MD file lives because there
- 28:35isn't only one place you can have it.
- 28:37Claude supports different levels of
- 28:39instructions. You can have personal
- 28:41instructions under the dot Claude folder
- 28:44and then Claude MD file, which applies
- 28:46across all your projects.
- 28:49So, if there's something you personally
- 28:51want Claude to follow everywhere, you
- 28:53can put it there.
- 28:54Then, there are project instructions.
- 28:58Inside your project in the root of the
- 28:59application, you can just put the Claude
- 29:01or agent MD file there.
- 29:04This is usually the one you'll use the
- 29:05most. For our luxury store application,
- 29:08this is where you can keep things like
- 29:10your stack, commands, database rules,
- 29:13testing rules, and storefront design
- 29:16rules. And you can also commit this file
- 29:18to get, so everyone working on the
- 29:20project gives Claude the same project
- 29:23instructions. This is something you
- 29:24might not have known about, but there
- 29:26are also local project instructions. You
- 29:29can also have something like a
- 29:30.claud.local.md,
- 29:33which is a file that only applies to you
- 29:36on this specific project. Maybe you use
- 29:38a local test account. Maybe you have
- 29:41your own sandbox URL. Things like that
- 29:44can live here and normally stay out of
- 29:46Git. And Claude can then use
- 29:48instructions from all of these levels
- 29:50together. And if you're working on a
- 29:52much larger code base or a monorepo,
- 29:55this can go quite a bit further.
- 29:57You can have multiple nested Claude MD
- 30:00files across different parts of the
- 30:02project. So, Claude only pulls the
- 30:04instructions that are relevant to that
- 30:06area it's actually working on. I don't
- 30:08want to go too deep into that here
- 30:10because this is a crash course, but this
- 30:12is exactly the kind of concept that I
- 30:14cover inside of the Agentic Engineering
- 30:16course. And because that course uses
- 30:19that completely free open-source Agentic
- 30:21Engineering workflow, you get a set of
- 30:24those reusable skills and commands that
- 30:26inspect your code base and help you set
- 30:29up the right project context
- 30:30automatically.
- 30:32What does that mean? Well, if your
- 30:34project is small, it may create only one
- 30:36Claude MD file.
- 30:38But, if the code base is much larger, it
- 30:40can create multiple nested Claude MD
- 30:43files, so each one is loaded only when
- 30:46Claude starts working on that specific
- 30:48part of the project.
- 30:50The workflow, of course, goes beyond
- 30:52context files, too, as it's built around
- 30:54helping you develop applications with
- 30:56stronger engineering and system design
- 30:58practices instead of just throwing
- 31:00prompts at an agent randomly. And yeah,
- 31:02you can use the workflow completely on
- 31:04your own since it's free and
- 31:05open-source, but if you want to learn
- 31:07how to use it properly alongside more
- 31:09advanced Claude concepts and the real
- 31:11agentic engineering course workflows,
- 31:14well, then check out the agentic
- 31:15engineering course. But for our Gucci
- 31:18store application, just having one
- 31:20project-level Claude MD file is more
- 31:23than enough for now. And you might also
- 31:25think, "But wait, doesn't Claude already
- 31:28have memory?"
- 31:29Well, it does. Claude code also has
- 31:32auto-memory, but the difference is
- 31:35simple. Claude MD is what you
- 31:37intentionally tell Claude.
- 31:40Auto-memory is what Claude learns while
- 31:42working with you. For example, while
- 31:44working on our Gucci store, Claude
- 31:47discovers some weird issue with your
- 31:49local setup. Or maybe you correct the
- 31:51same project-specific behavior a couple
- 31:53of times.
- 31:54Claude can save useful things like that,
- 31:57so they can be used again in future
- 31:59sessions. Each project gets its own
- 32:01memory folder with a memory.md as the
- 32:04main file.
- 32:05Claude can also create other memory
- 32:07files for more specific things. To see
- 32:10what is stored, you can just run
- 32:13and you can see that the auto-memory has
- 32:15been turned on with the project
- 32:17instructions checked in at the Claude MD
- 32:19file.
- 32:20There are some additional instructions
- 32:22and user instructions.
- 32:25And you can also open up the auto-memory
- 32:27folder. And then to see what Claude has
- 32:29stored within your current session, you
- 32:31can just run context.
- 32:34This will show you how much of the
- 32:35context has currently been spent and
- 32:37show you the estimated usage by the
- 32:40category. So, the main question is
- 32:43what should actually go into a Claude or
- 32:46Agent MD file?
- 32:48A simple rule is like this.
- 32:50If removing this instruction would
- 32:52probably make Claude assume the wrong
- 32:55thing,
- 32:56then keep it.
- 32:57Otherwise, ask whether Claude really
- 33:00needs it in every session.
- 33:02For example, inside of our Gucci store,
- 33:05we can give it some commands to run.
- 33:07Like a package manager is PNPM with the
- 33:10start dev server command being PNPM dev.
- 33:13And we can also share the commands to
- 33:15run the tests or run the type check.
- 33:18Later on, once you add the database, we
- 33:20can also give it some information such
- 33:22as use drizzle for all database access.
- 33:25We can specify where the database schema
- 33:28lives, such as in source DB schema.
- 33:31And we can also tell it to never write
- 33:33raw SQL queries unless specifically
- 33:36requested. These are some important
- 33:37pieces of info. And once we set up the
- 33:39storefront design, we can also tell it
- 33:42to keep the customer-facing pages
- 33:44editorial and product-focused. To reuse
- 33:47the existing design system, to avoid the
- 33:49dashboard style UI, and to not include
- 33:52any of those purple gradients.
- 33:55These are useful because they actually
- 33:57change how Claude should work.
- 34:00Now, compare that with something like
- 34:02write high-quality code, follow best
- 34:05practices, make the UI beautiful, or
- 34:08keep everything clean.
- 34:10These sound nice, but they don't really
- 34:13tell Claude anything useful. It's the
- 34:16same with make the landing page premium.
- 34:19But what does that actually mean?
- 34:22Instead, you could say use large product
- 34:24imagery, generous spacing, and
- 34:27restrained controls on storefront pages.
- 34:30That's something Claude can actually
- 34:32follow. And don't dump your entire
- 34:34project structure or huge API
- 34:36documentation into Claude or agent MD
- 34:38file either. Keep the things Claude
- 34:41should know every time it works on this
- 34:43project. And the wording matters, too.
- 34:46Instead of saying format the code
- 34:48properly, say use two space indentation.
- 34:52Or instead test your work, say something
- 34:55like run pnpm test before finishing the
- 34:57task. Or instead of keep the API code
- 35:01organized, you can say something like
- 35:03API handlers live in source API
- 35:06handlers. The more specific you are, the
- 35:09less Claude has to guess what you meant.
- 35:12And if the file starts becoming huge,
- 35:15don't just keep throwing everything at
- 35:16it. Claude code also supports the Claude
- 35:19rules, where you can split instructions
- 35:22into separate files. For example, within
- 35:25the dot Claude folder, you can have the
- 35:27Claude MD file, and then you can have
- 35:29the additional rules folder, within
- 35:31which you can have something like
- 35:33testing.md, database.md, storefront, or
- 35:37security.md.
- 35:38You can even make rules apply only to
- 35:40certain files by giving it a specific
- 35:43path and setting out the rules.
- 35:46Now, Claude only needs those rules when
- 35:49it's working in matching files.
- 35:51That helps you keep the rest of the
- 35:53context clear. And if something isn't
- 35:55really a rule, but rather a process that
- 35:58you keep doing again and again, that
- 36:00usually belongs in a skill, but we'll
- 36:03get to that later.
- 36:05For now, we can create our first Claude
- 36:07MD file by running init.
- 36:10There's no need to do it from scratch.
- 36:12So, just have your Claude window open
- 36:14and type init. And as you can see, this
- 36:17will initialize a new Claude MD with the
- 36:20codebase documentation. It'll pick up
- 36:22things like the package manager, the
- 36:24framework, the build commands, tests,
- 36:26and other project conventions.
- 36:29And if you already have a Claude MD, in
- 36:31it can suggest changes instead of simply
- 36:34replacing it.
- 36:35But don't just accept whatever Claude
- 36:37creates.
- 36:38Read it. Once it's done, you can either
- 36:40read it right here, or you can head over
- 36:43into the Claude MD or the agent MD file
- 36:46that it created. We can then preview it
- 36:49either in markdown or with a nice
- 36:51previewer like this, which you can
- 36:52install as a VS Code extension. Here you
- 36:55can see the commands, the architecture,
- 36:57the Next JS 16 notes as well.
- 37:00It is all here.
- 37:02But if Claude added something it can
- 37:04easily figure out from package.json, ask
- 37:06whether you really need it taking up the
- 37:08context every time.
- 37:10And if something is wrong, fix it.
- 37:12And then add the things that Claude
- 37:14couldn't know just by reading the code.
- 37:16For example, Claude can see that we are
- 37:18using Tailwind, but it can't
- 37:20automatically know that we're building a
- 37:22Gucci store, which needs to feel
- 37:24editorial and product focused, or that
- 37:27you don't want a simple dashboard style
- 37:29UI.
- 37:30That's the kind of information that
- 37:32belongs here. And how do you know this
- 37:34file is actually getting loaded? Well,
- 37:36open up Claude and run context. If you
- 37:39do it and then check the memory files,
- 37:42you can see the memory right here,
- 37:44and you can run {slash} context all to
- 37:47expand it.
- 37:48That way, you can see exactly where your
- 37:51context is being spent.
- 37:53And on top of checking the context, you
- 37:55can also check the memory.
- 37:57And here you can see where it's
- 37:58extracting it from. Now, another pro tip
- 38:01with the Claude MD file is to not just
- 38:04create it once and then forget about it.
- 38:07Your project changes, commands change,
- 38:09and the architecture changes, too.
- 38:11Maybe your database layer lives in one
- 38:13folder today, and later you move it
- 38:16somewhere else.
- 38:17If Claude MD still tells Claude to use
- 38:19the old location, you're now giving it
- 38:22wrong information before it even starts
- 38:24the task. So, keep the file updated.
- 38:27Remove things that aren't true anymore,
- 38:30and don't keep adding new rules forever,
- 38:32either.
- 38:33Sometimes, the right change is just
- 38:35deleting an old one. And in our Agentic
- 38:38engineering workflow, we have a skill
- 38:40for that.
- 38:42It's called sync. What it does is it
- 38:45keeps all the context files up to date.
- 38:48It checks your latest Git commits,
- 38:50figures out what changed, and updates
- 38:52the information automatically across
- 38:54your ClaudeMD and AgentMD files
- 38:57automatically. So, now that we have this
- 38:59ClaudeMD file, Claude knows how you want
- 39:02this project to work. But, the next
- 39:03question is, how much freedom should you
- 39:06give it? When should Claude stop and
- 39:09show you a plan first?
- 39:11Or, which files should it be allowed to
- 39:13touch?
- 39:14Which commands should it be allowed to
- 39:15run?
- 39:16That's where the plan mode and the
- 39:18additional permissions come in.
- 39:22Thanks to our ClaudeMD, Claude now knows
- 39:26how we want this project to be
- 39:27structured. So, let's keep building this
- 39:29app while learning more of what Claude
- 39:32Code can do.
- 39:33But, before we do that, there's one
- 39:35thing you should check. Look at the
- 39:37current Claude Code mode you're in.
- 39:39Claude Code can work with different
- 39:41levels of freedom depending on the mode
- 39:43you're using.
- 39:45There's manual, where Claude asks before
- 39:48actions that need your approval.
- 39:51There's the edit automatically, where
- 39:53normal file edits can happen without
- 39:56asking you every time.
- 39:58There's plan, where Claude can inspect
- 40:01and think through the project without
- 40:03immediately editing your source files.
- 40:05And there's auto, where Claude can
- 40:08approve many actions itself after
- 40:10checking whether they match what you
- 40:12asked it to do. And there are a few
- 40:14other modes for more restricted or
- 40:17isolated workflows, but you don't need
- 40:19them right now. The important thing is
- 40:21to know which mode you're actually
- 40:23using. Because if your Claude code is
- 40:25currently in auto mode, you may see
- 40:28Claude editing files and running things
- 40:30without showing the same permission
- 40:32prompts I'm seeing.
- 40:33That doesn't mean permissions aren't
- 40:35working. It just means you're giving
- 40:36Claude a different level of freedom. And
- 40:39you can cycle between modes right here
- 40:41if you're using the VS Code extension or
- 40:43if you're using it in console,
- 40:46you can just press shift tab to switch
- 40:50between the modes right here. I almost
- 40:52always have it on auto mode on.
- 40:55But for this first feature we'll
- 40:57implement, let's switch it over to
- 40:59manual mode so we can better understand
- 41:01how it's working. And let's start with
- 41:04our first real feature, building the UI
- 41:08of our storefront.
- 41:09Instead of randomly designing pages,
- 41:12let's give Claude an actual reference.
- 41:15We'll use Gucci's current website as
- 41:17inspiration, but we're not copying their
- 41:19branding, assets, or content. So, let's
- 41:22tell it something like study
- 41:26the current Gucci website as a visual
- 41:31reference for this e-commerce
- 41:34application.
- 41:35And of course, that website might be
- 41:37completely different depending on when
- 41:39you're watching this video, but that's
- 41:40totally okay.
- 41:42You might just have a newer design than
- 41:43what I have. And when I'm developing
- 41:45apps myself, I don't typically type.
- 41:49That sounds a bit weird knowing that we
- 41:51all code a lot, but lately I've been
- 41:54more narrating the prompts and the
- 41:56commands for my agent. I use the tool
- 41:59called WhisperFlow, which you can see
- 42:01here at the bottom, but there's many of
- 42:02these different tools that you can use
- 42:04to speak to your agent. Let me show you
- 42:07how that works. I'll press the command
- 42:08key on my keyboard and continue telling
- 42:10it the prompt. Analyze its typography,
- 42:13spacing, layout, navigation, product
- 42:16presentation, imagery, buttons, borders,
- 42:19colors, and responsive behavior without
- 42:22copying its text, assets, or branding.
- 42:25Something like this.
- 42:26Feel free to take your time to copy
- 42:28this.
- 42:29And then I'll say,
- 42:31"Then, implement those principles in our
- 42:33project by setting up the global design
- 42:36system, including typography, color
- 42:39tokens, spacing, containers, buttons,
- 42:42links, borders, and reusable responsive
- 42:45primitives in the appropriate Tailwind
- 42:47and CSS files." And then finally,
- 42:50"Briefly explain the rules you
- 42:52implemented and the files you changed."
- 42:55Now, press enter
- 42:57and watch what happens next. Claude may
- 43:00use web search or web fetch to research
- 43:04that reference.
- 43:05And only then it'll start working within
- 43:08your project.
- 43:09Yep, there we go. Fetch. And it's even
- 43:12using a front-end design skill that I
- 43:14have loaded.
- 43:16And because you're in manual mode,
- 43:17you'll start seeing permission prompts
- 43:20whenever Claude wants to make changes or
- 43:22run commands that need your approval.
- 43:25You might need to approve an edit, then
- 43:27approve another, then Claude might want
- 43:30to do something else, and you need to
- 43:32approve that, too. So, let's give it
- 43:34some time. There we go. Do you want to
- 43:36allow Claude to fetch this content? Yep,
- 43:39we do. Then again, do you want to
- 43:41proceed with this? Yep, we want to
- 43:42proceed with the web search. And
- 43:44throughout the rest of this task, it
- 43:46might ask us to do this a couple of
- 43:48times.
- 43:49Yep. Yep.
- 43:51We want to allow Claude to fetch more
- 43:53websites to figure out exactly what we
- 43:55want.
- 43:56And after some time, you'll start
- 43:58thinking, "Do I really have to approve
- 44:00everything every single time?"
- 44:04And that's where the permissions become
- 44:07useful.
- 44:08Because permissions let you decide what
- 44:11Claude can do automatically, what it
- 44:13should ask you about, and what it
- 44:16shouldn't be allowed to do at all. And
- 44:18there are three basic rule types: allow,
- 44:21ask, and deny. Allow means that Claude
- 44:25can perform that matching action without
- 44:27asking you.
- 44:29Ask means that Claude has to stop and
- 44:31get your approval, and deny means that
- 44:34Claude code blocks it.
- 44:36And if several rules match, Claude
- 44:38checks them in order of deny, ask, and
- 44:41allow. So, deny wins first. You can
- 44:44inspect the permissions that you have
- 44:46with your current project after it
- 44:48finishes doing its thing,
- 44:50and then running permissions.
- 44:52Permissions will show you which
- 44:54permissions you currently have,
- 44:55such as which allow, which ask, deny, or
- 44:59whether it is set to the auto mode with
- 45:01soft allow, soft deny, and so on.
- 45:05So, you can check all of those
- 45:06permissions right here. You might have
- 45:08also noticed that when Claude asked us
- 45:10for permissions,
- 45:12it asked whether we want to allow it
- 45:14once or whether we want to allow it from
- 45:16here onward.
- 45:18So that we don't have to approve that
- 45:20same or similar action again.
- 45:22That's useful because you probably don't
- 45:24need to approve the pnpm build command
- 45:26for the 15th time.
- 45:28But you also shouldn't click don't ask
- 45:30again on everything without thinking
- 45:32about what you're allowing. So, it looks
- 45:34like our design system is in,
- 45:37and we should be able to see it right
- 45:38here within our source,
- 45:41app, and then globals.css.
- 45:43All of the colors, type fonts, and
- 45:46texts, and headings, and buttons, all of
- 45:48it is right here.
- 45:50We'll take a look at that soon, but now
- 45:52let's set up permissions for our store.
- 45:56What would make sense for this project?
- 45:58Well, Claude will probably run commands
- 46:00like pnpm dev, build, test, or type
- 46:04check every now and then. These are
- 46:06normal development checks, and you may
- 46:08want Claude to run them without stopping
- 46:11you each time. But, git push is
- 46:13different. Maybe you always want to see
- 46:16before it happens.
- 46:18And later on, your project will contain
- 46:20things like the database URL or some
- 46:23other environment variables.
- 46:25Claude shouldn't be able to read those.
- 46:28So, you can keep project permission
- 46:30rules inside of the dot Claude folder.
- 46:34If it doesn't exist already, you can
- 46:36create one by creating a new dot Claude.
- 46:40And then within it, you can create a new
- 46:42file called settings.json.
- 46:45For example, inside of there, you can do
- 46:48something like this. Inside of a new
- 46:50JSON object, you can add the permissions
- 46:53and then split them by allow, ask, and
- 46:56deny, just as we talked about.
- 46:59Now, under allow, I gave it permission
- 47:02to run PNPM build, test, run git status,
- 47:05and so on.
- 47:06But, I wanted it to ask before it pushes
- 47:09anything, and I want to explicitly deny
- 47:12that it reads our ENV files.
- 47:15With that, you've created a much more
- 47:17useful baseline. Claude can run the
- 47:20normal checks you'd expect. It will ask
- 47:22before pushing, and your environment
- 47:25files are blocked from its normal
- 47:27access. So, this is where the difference
- 47:29from the previous lesson becomes clear.
- 47:32Inside of the Claude code file, you
- 47:35could write never read .env,
- 47:39and Claude should follow that
- 47:41instruction. But, it's still guidance
- 47:44you're giving to the model.
- 47:46A permission rule set is different. When
- 47:49something matches a deny rule, Claude
- 47:51code itself will block that action. So,
- 47:55use Claude.md for things like, "Hey, use
- 47:58the existing design system when building
- 48:00the storefront pages."
- 48:02But, use permissions for things like,
- 48:05"Claude, you shouldn't read this file."
- 48:08So, Claude MD simply tells Claude how
- 48:12you want it to work. But, permissions
- 48:14decide what Claude code is actually
- 48:17allowed to do. And just like with the
- 48:20code, don't set up permissions and
- 48:22assume everything works. You may not
- 48:24have a real.env yet, so create a
- 48:27temporary example file. Or test that
- 48:30rule later when the database is added.
- 48:32For now, we have this .env.example,
- 48:35but I'll go ahead and copy it and create
- 48:37a new .env and paste what we have in
- 48:40there. And let's assume that this
- 48:42includes the actual password. Now, we
- 48:44can open up Claude and tell it to read
- 48:46the .env and tell me what's inside it.
- 48:49Claude code should block the access.
- 48:53First, it'll ask us to run the bash
- 48:55command because we're still in manual or
- 48:58auto-accept edits mode, but once it
- 49:00reaches that file, it'll say, "I can't.
- 49:03Reading that file is blocked by this
- 49:06session's permission settings. File is
- 49:08in a directory that is denied by your
- 49:10permission settings."
- 49:12I didn't try to route around it with a
- 49:13cat since the deny rule is clearly aimed
- 49:16at .env contents specifically.
- 49:18And you can always run the permissions
- 49:21command to check which rules are under
- 49:23allow, ask, or deny.
- 49:26Now, let's see what the experience feels
- 49:28like with those permissions set.
- 49:31Since we already have a full design
- 49:33system put in place right here within
- 49:36the app.globals.css,
- 49:38we can ask Claude to build the first
- 49:40home page. For example, we can tell it
- 49:43to build the first complete home page
- 49:45for the e-commerce storefront using the
- 49:48design system already set up in the
- 49:50project.
- 49:51We can then continue telling it to take
- 49:54inspiration from the way premium fashion
- 49:56websites like Gucci use large editorial
- 49:59imagery, featured collections, and
- 50:01product focus sections.
- 50:03And finally, we can tell it to use
- 50:05simple sample product and collection
- 50:07data where needed with images from
- 50:09Unsplash or other sources.
- 50:11We want to make it responsive and verify
- 50:13the result when it's done.
- 50:16And run it. Now, if you watch Claude
- 50:19again, it can make the changes it needs
- 50:21and when it wants to run one of the
- 50:23commands you've already allowed, it
- 50:26doesn't need to interrupt you every
- 50:27time. But for some things like running
- 50:30bash commands, it might still ask you
- 50:31for permission. The goal is that you're
- 50:34not trying to remove every permission
- 50:36prompt, but rather you're trying to
- 50:38remove the boring ones that you already
- 50:40understand while keeping control around
- 50:42the things that matter. But to be
- 50:44honest, the auto mode has gotten so
- 50:46advanced that I typically leave it on
- 50:49and I'm totally happy with the amount of
- 50:50permissions that Claude code has by
- 50:52default.
- 50:54So, that's what I'll shift it to by
- 50:56using shift tab. And let's let it finish
- 50:59running this task. And after some time,
- 51:02it is done. Here, it gave us the final
- 51:05explanation of what happened,
- 51:07the files it changed, and so much more.
- 51:11So, what do you say that we run the
- 51:13application for the first time and check
- 51:15it out?
- 51:16I'll open up a secondary terminal and
- 51:19run npm dev as that's what we're using
- 51:22to run the application. And then I'll
- 51:24open it up on localhost 3000.
- 51:26You can either open it up within your
- 51:28browser or nowadays, even VS Code has
- 51:31its built-in browser.
- 51:33Since this is a large-scale
- 51:36pretty well-designed application, I
- 51:38definitely want to open it up within the
- 51:40browser. So, check it out.
- 51:43Complimentary delivery and returns,
- 51:45atelier, and here we have the long coat,
- 51:49as well as some of the additional
- 51:50collections of the printed silk,
- 51:52outerwear, and leather goods.
- 51:55This is looking like a real store. So,
- 51:58just from a single prompt, we were able
- 52:00to get a pretty good output.
- 52:03Of course, the other pages are not going
- 52:04to work right now, like the products
- 52:06page, but that's going to be the next
- 52:08step. For now, we only have the home
- 52:10page, and sure, we can play with the
- 52:12hero section to present it a bit better.
- 52:15But, now I want to be able to open up
- 52:18one of these product detail pages.
- 52:21That's going to be under products, and
- 52:23then the product name. So, back into the
- 52:25application, open up the terminal,
- 52:27head over to Claude, and let's tell it
- 52:30something along the lines of build the
- 52:33product detail page with large imagery,
- 52:35product information, price, category,
- 52:38and stock state. Keep it consistent with
- 52:40the home page and product listing.
- 52:43And run it.
- 52:45I'm running it on auto mode, so now we
- 52:47shouldn't be getting as many permission
- 52:49questions.
- 52:50And a couple of minutes in, the product
- 52:52detail page is built and verified. The
- 52:56build passes, and all 13 product pages
- 52:59pre-render as static HTML with lint
- 53:02being clean. You can see all the files
- 53:04that have been changed right here,
- 53:06information about how the page is
- 53:07structured, and that is it. And all of
- 53:11this only took 21% of the context
- 53:13window. So, let's quickly check it out
- 53:16by re-running our application, opening
- 53:19it up on localhost 3000, and then
- 53:21opening a specific product details page,
- 53:23such as this Jorno soft backpack.
- 53:27A nice product page opens. We can see a
- 53:30static product information on the right,
- 53:32while the images on the left scroll. And
- 53:34then we can see the recommended product
- 53:36section at the bottom. And all of this
- 53:38really feels like a polished editorial
- 53:41Gucci-inspired style website. But, with
- 53:44all of this, we're still not setting up
- 53:46the real database.
- 53:48Right now, we're working on the customer
- 53:49experience and making sure that the
- 53:51design, components, and the page
- 53:54structure feels right.
- 53:56And these are exactly the kind of things
- 53:58where letting Claude edit normally makes
- 54:00sense.
- 54:01If the product grid is wrong, you can
- 54:03easily change it. Or, if you don't like
- 54:05a specific section like this one, you
- 54:08can redesign it. And if the spacing is
- 54:10off, Claude can fix it on its own.
- 54:13These changes are easy to review, and
- 54:16therefore easy to undo as well.
- 54:19And that's how you should approach
- 54:20building with AI in general.
- 54:22Instead of asking it to build the entire
- 54:25store in one prompt, and then wondering
- 54:27what it did, you break the work into
- 54:29small features. Let Claude build one,
- 54:32review it, accept it or undo it, and
- 54:34then move on to the next one. That is
- 54:36what agentic engineering is all about.
- 54:39So, at this point, our atelier is
- 54:41starting to look like an actual
- 54:43e-commerce application.
- 54:44You've got the main project set up, the
- 54:47Claude.md file right here up and running
- 54:50giving Claude instructions, a design
- 54:53system within the globals.css
- 54:56based on a real reference.
- 54:58You also have storefront homepage right
- 55:01here in the page. There's also the
- 55:04product listing pages,
- 55:06as well as project permissions that
- 55:08remove unnecessary approvals while
- 55:10protecting more important sections. And
- 55:13notice how you learned about those
- 55:15permissions. You didn't memorize a
- 55:17settings file and moved on. You saw the
- 55:20problem first.
- 55:21Claude kept asking before it could work.
- 55:24Then, you decided which actions were
- 55:26safe enough to allow, and which ones
- 55:29should still stay under your control.
- 55:31And that's how most of the rest of this
- 55:33course will work, too. So far, the
- 55:35features you build are relatively easy
- 55:37to change.
- 55:38If you don't like the homepage, redesign
- 55:41it.
- 55:41Or if a product card is wrong, just
- 55:44change it.
- 55:45But the next step is different.
- 55:48You need to add the real database layer.
- 55:51That means Postgres, Drizzle, products,
- 55:54categories, inventory, and database
- 55:56migrations. And those decisions are
- 55:58harder to undo casually.
- 56:01And for something like that, you may not
- 56:03want Claude to immediately start writing
- 56:05code the moment you describe the
- 56:07feature.
- 56:08You may want it to inspect the project
- 56:10first and show you exactly what it plans
- 56:13to do.
- 56:14And that's exactly where the plan mode
- 56:19comes into play.
- 56:20So, let's talk about that next.
- 56:24Now, let's use the plan mode on the
- 56:26first part of our e-commerce application
- 56:29where the approach actually matters,
- 56:32which is the real database.
- 56:34You can either approach it through the
- 56:36VS Code extension by selecting the plan
- 56:38mode right here and then tell it what to
- 56:40do, or you can do it through the
- 56:42terminal. If you start a new session,
- 56:45this would be a great place to clear the
- 56:47context,
- 56:48and then you can simply run
- 56:49{forward-slash} plan to enable the plan
- 56:52mode or view the current session plan.
- 56:55Or you can shift to it naturally by
- 56:56holding the shift key and then tapping
- 56:58onto plan mode. Here, we can ask it to
- 57:01inspect the current e-commerce project
- 57:04and plan how to replace the current
- 57:07product data with a real Postgres
- 57:09database using Drizzle ORM.
- 57:12We can also continue to say that for
- 57:14now, we only need products, categories,
- 57:17and stock.
- 57:19We can then ask it to study how the
- 57:21existing storefront currently uses
- 57:23product data before deciding the schema.
- 57:25And since we're just starting off, we
- 57:27want to keep this first version simple.
- 57:29Don't add carts, orders, payments,
- 57:32reviews, wish lists, or product variants
- 57:34yet. And most importantly, we want to
- 57:37ask it to show us the database
- 57:39structure, relationships, files that
- 57:42need to change, migration approach, and
- 57:44how the existing storefront will start
- 57:47using the database.
- 57:49Press enter and watch Claude work.
- 57:53In plan mode, Claude can now inspect,
- 57:56search, and research, but normal source
- 57:59edits stay blocked until you approve the
- 58:01plan.
- 58:02You can see that it started a new agent
- 58:04right here on main, as well as it
- 58:06started a sub-agent on the explore part,
- 58:09where it's exploring how the storefront
- 58:12uses the product data right now. And if
- 58:14you want to see what that sub-agent is
- 58:16doing, you can just head over to it,
- 58:18press enter, and then you can see what
- 58:20that agent is doing right here, or you
- 58:21can go back to the main session. Looks
- 58:23like it already has a clear picture of
- 58:25the current data layer, so it's going to
- 58:27confirm a few schema decisions. And now,
- 58:30Claude got back to us with a couple of
- 58:31questions.
- 58:32How should the stock be represented in
- 58:35the database?
- 58:36Well, it can be quantity plus derived
- 58:38state. Yep, that looks good to me. How
- 58:40should the multiple product images be
- 58:42stored? Well, we can use separate
- 58:44product images table.
- 58:46The home page collection strip, printed
- 58:48silk outerwear leather goods, overlaps
- 58:50with the product categories. Well, those
- 58:52can just be categories.
- 58:54Uh the home page has two hard-coded
- 58:55list. Well, we just want to order it by
- 58:57created at. I basically accepted all the
- 59:00recommended options because in this
- 59:02case, they fit what I was after. So, we
- 59:05can submit the answers and let the agent
- 59:07continue planning. Without these
- 59:09questions, if you just accepted what
- 59:11Claude gave you, and you immediately
- 59:13press approve without actually reading
- 59:15the plan, you've gained almost nothing.
- 59:19The whole point is to catch bad
- 59:21decisions before they become code.
- 59:25For this database, we want to check
- 59:27things like what tables Claude wants to
- 59:30create. How products and categories
- 59:33connect, where the stock is stored and
- 59:36how, how prices are represented, where
- 59:39the drizzle schema will live,
- 59:41which files need to change, and how
- 59:43Claude plans to verify the result.
- 59:46A weak plan might sound something like
- 59:49add database, add products, update
- 59:51storefront, but that doesn't tell you
- 59:54much. A useful plan should show that
- 59:56Claude understood the current
- 59:58application and can name the actual
- 1:00:00parts of the codebase that will change.
- 1:00:03While it's doing its thing, I want to
- 1:00:05give you an example. So, I'll head over
- 1:00:07into our readme,
- 1:00:09and I'll just paste something at the
- 1:00:10top. You can also open it in preview.
- 1:00:13Just imagine that Claude says something
- 1:00:15like this.
- 1:00:16Create separate products, product
- 1:00:18variants, inventory locations, and more.
- 1:00:21You could stop right there and say,
- 1:00:24"That's too much for where it is right
- 1:00:25now. Keep stock directly on the product
- 1:00:29and only create what we currently need."
- 1:00:31That only takes a few seconds, but if
- 1:00:34you catch the same mistake after Claude
- 1:00:36has already created the schema,
- 1:00:38generated migrations, and changed the
- 1:00:40storefront, well, then there's much more
- 1:00:42to undo.
- 1:00:44And that's one of the biggest reasons to
- 1:00:46use the plan mode. The cheapest place to
- 1:00:49fix a wrong decision is in the plan, not
- 1:00:52after the code is written. So, back in
- 1:00:54the terminal, it looks like Claude
- 1:00:57presented us with a plan. The goal is to
- 1:00:59move the catalog into Postgres. It gave
- 1:01:02us context on all of that, the database
- 1:01:04plumbing, and even which files should
- 1:01:06change.
- 1:01:07You should analyze all of this in
- 1:01:09detail. It's specifying which column is
- 1:01:11it going to add, how our database is
- 1:01:13going to be structured, and more. And
- 1:01:15you could even ask it to turn this into
- 1:01:17a markdown file so you can review it
- 1:01:19more nicely. If you want to edit the
- 1:01:20plan directly, you can just press Ctrl G
- 1:01:23to open it up. And once you do that,
- 1:01:26it'll be opened up in a new markdown
- 1:01:28window.
- 1:01:29Here, you can even preview it for a bit
- 1:01:31of a nicer view, and spend some time,
- 1:01:34maybe even 5 to 10 minutes, going over
- 1:01:36the plan and noting down or directly
- 1:01:39changing right here all the things that
- 1:01:41you think should change. And only when
- 1:01:43you're happy with the approach, you can
- 1:01:45approve it.
- 1:01:47One important thing to know is that
- 1:01:49approving the plan exits the plan mode.
- 1:01:52Claude doesn't stay in the same
- 1:01:54read-only state afterward. So, you can
- 1:01:57choose how you want to continue, and
- 1:01:58then Claude moves into the
- 1:02:00implementation. In this case, we can say
- 1:02:02yes, proceed, execute the plan, and use
- 1:02:05auto mode. And that's exactly what it'll
- 1:02:07proceed to do. And one important thing
- 1:02:09to know is that approving the plan exits
- 1:02:12the plan mode. As you can see on my end
- 1:02:15right here, it finished, and we're back
- 1:02:18in the auto mode. Now, in this plan, or
- 1:02:21the execution of the plan, we set some
- 1:02:24very important foundations for the rest
- 1:02:26of the application.
- 1:02:27And that's something that's not only
- 1:02:30useful for this one task, but something
- 1:02:33that Claude should probably remember
- 1:02:34every time it works on this database.
- 1:02:37So, we can tell Claude to update the
- 1:02:40Claude.md with only the database
- 1:02:43conventions from this decision that
- 1:02:45Claude should remember in future
- 1:02:46sessions. It'll take a look at what it
- 1:02:48did, and it'll read and then update the
- 1:02:51Claude.md. We want to keep it short and
- 1:02:53don't add things that Claude can easily
- 1:02:55discover from the code base.
- 1:02:57It might end up with, just as you can
- 1:03:00see right here, an additional seed
- 1:03:02command,
- 1:03:03as well as some database-specific
- 1:03:05configurations, such as where the
- 1:03:07schemas are stored, the catalog, and so
- 1:03:10much more. And that's it. This is
- 1:03:12exactly how Claude.md should grow.
- 1:03:14Not because you want a bigger file, but
- 1:03:17because the project has now made a real
- 1:03:19decision that Claude should remember.
- 1:03:21And if Claude keeps making the same
- 1:03:23wrong assumption every time you plan
- 1:03:25something, that's usually a sign that
- 1:03:27your project instructions are either
- 1:03:29missing or are wrong. Okay, so as we
- 1:03:32approved the plan, Claude went into
- 1:03:35building. We can zoom out a bit because
- 1:03:37there's a lot of stuff that happened
- 1:03:38right here, and we can read its update.
- 1:03:41Claude first configured drizzle, then it
- 1:03:44created three additional tables and
- 1:03:46schemas for them. It set up a database
- 1:03:48connection, generated migrations,
- 1:03:51created seed data, so we can seed our
- 1:03:54database. It updated the product
- 1:03:56queries, and connected the storefront to
- 1:03:59Postgres.
- 1:04:00The important part is that Claude isn't
- 1:04:02inventing the direction anymore. It's
- 1:04:05implementing the approach that we
- 1:04:06reviewed. But at some point, you'll need
- 1:04:09a real Postgres connection string. So,
- 1:04:12let's create a database using any kind
- 1:04:14of a provider.
- 1:04:15In this case, I'll use Neon as it's free
- 1:04:18and easiest to set up.
- 1:04:20So, simply create your account. You can
- 1:04:22use any provider.
- 1:04:25Then, create a new project. Let's call
- 1:04:28it Atelier
- 1:04:29Store.
- 1:04:31You can choose the region that is
- 1:04:32closest to you.
- 1:04:34And just click create project. The
- 1:04:36project was created, so you can head
- 1:04:38over into it. Then, click connect. And
- 1:04:41here, you'll be able to connect your
- 1:04:42database. Simply copy this connection
- 1:04:44string.
- 1:04:46Head back into the application under the
- 1:04:48.env.
- 1:04:50Or in this case, we can rename it to
- 1:04:51.env.local
- 1:04:53because that is the .env that we're
- 1:04:55going to use locally on this device. And
- 1:04:57then here, we can update the database
- 1:04:59URL with the one we just copied. You
- 1:05:02don't want to paste the secret into
- 1:05:03Claude.
- 1:05:05Instead, you want to add it here, and
- 1:05:07we'll use that to run the application,
- 1:05:09but we'll never tell it to Claude. And
- 1:05:12now we want to test the whole database
- 1:05:14end to end. Such as running migrations
- 1:05:17right here that were generated and
- 1:05:18inspected for us.
- 1:05:20Claude should have created a command for
- 1:05:22us in order to be able to do that. I
- 1:05:24believe the command in question is the
- 1:05:26one that it added to Claude. So we can
- 1:05:28even tell it to run the migration and
- 1:05:30seed now that the database URL is set.
- 1:05:33And I love how it auto recommended that
- 1:05:35line for us.
- 1:05:37It's going to check what's in the
- 1:05:38database. It'll create a script and very
- 1:05:41soon it'll run that script. But in the
- 1:05:44meantime it says that it can't run it
- 1:05:46because database URL isn't reaching my
- 1:05:48shell.
- 1:05:49Maybe it is specifically looking for
- 1:05:51.env and not .env.local.
- 1:05:54So I'll remove that .env part and tell
- 1:05:57it to try again.
- 1:06:00There we go. It got connected and the
- 1:06:03database is empty with no auth tables.
- 1:06:05So our first migration applies cleanly.
- 1:06:08Great. Now it'll verify whether data
- 1:06:10landed correctly, but we can also verify
- 1:06:12on our end by heading over into Neon
- 1:06:16tables
- 1:06:17and you can see the account, categories,
- 1:06:19products. All of the data is actually
- 1:06:22right here.
- 1:06:24We can even verify an image I believe if
- 1:06:28we find where the images are stored.
- 1:06:32There we go, product images.
- 1:06:34And here we can see the URLs from
- 1:06:36Unsplash.
- 1:06:37So if you were to copy this entire URL
- 1:06:40you would be able to see the image. But
- 1:06:42we'll see it in our application soon. So
- 1:06:44with that in mind, we can now actually
- 1:06:46run our application by opening up the
- 1:06:48terminal and running pnpm dev to spin it
- 1:06:51up on localhost 3000. So back in the
- 1:06:53browser, heading over to localhost 3000
- 1:06:57if you reload, you should be able to see
- 1:06:59the application and it looks very
- 1:07:01similar as it did before, but now it's
- 1:07:05actually pulling the real data from the
- 1:07:08database. And that's the beauty of it.
- 1:07:10So, before we proceed, we can now open
- 1:07:13up Claude and tell it to show me the
- 1:07:15important changes you made and explain
- 1:07:18anything that I should review carefully.
- 1:07:22Or you can run git diff in your
- 1:07:25terminal. Maybe I can open up another
- 1:07:26one. And this will tell us all the file
- 1:07:28changes that happened recently. You can
- 1:07:30also explore them right here.
- 1:07:33But yeah, let's see what Claude itself
- 1:07:35thinks that we should review. And there
- 1:07:37we go. Here's the walk-through. The
- 1:07:39important changes. Stock became a number
- 1:07:42and the states became derived. So, here
- 1:07:45we can see how we are handling the state
- 1:07:47behavior of how many items do we have in
- 1:07:50stock available to order.
- 1:07:52Before sold out was typed by hand per
- 1:07:54product. Now, nothing stores a state.
- 1:07:57Two columns do and every badge, tone,
- 1:08:00and disabled button follows them.
- 1:08:02Two. One mapper is the same between the
- 1:08:05database and the UI. So, in this case,
- 1:08:07we have the price, the compare at price,
- 1:08:09the images, the badge, and the stock.
- 1:08:11And every query returns the product
- 1:08:13data, never a row. And that's why a
- 1:08:16product card and the detail page JSX are
- 1:08:18left untouched since nulls and foreign
- 1:08:21keys stop here. And there's a couple
- 1:08:23more things that we should review
- 1:08:24carefully. In this case, plan mode
- 1:08:27helped us catch the wrong direction
- 1:08:29early. But it still doesn't replace
- 1:08:32reviewing what was actually built.
- 1:08:34If Claude starts drifting, replan by
- 1:08:37going back into the plan mode and then
- 1:08:40update the approach based on the new
- 1:08:41information.
- 1:08:43That's better than letting a wrong
- 1:08:44direction spread across the project and
- 1:08:47trying to clean it up afterward. But
- 1:08:49before we keep building, there's one
- 1:08:51thing I want to talk about. It's
- 1:08:53security. And this has become a
- 1:08:55genuinely wild topic recently. In July
- 1:08:582026, OpenAI disclosed that two of its
- 1:09:02models, during an internal cybersecurity
- 1:09:05evaluation, escaped their sandbox
- 1:09:08testing environment by exploiting a
- 1:09:11zero-day vulnerability,
- 1:09:13reached the internet, and compromised
- 1:09:15parts of the Hugging Face's production
- 1:09:17infrastructure. And the reason for that?
- 1:09:20They were trying to find answers so they
- 1:09:23could cheat on the benchmark they were
- 1:09:25being evaluated on. Yep, I'm not joking.
- 1:09:29A week later, Anthropic reviewed its own
- 1:09:32cybersecurity evaluations and found
- 1:09:35incidents where Claude models had gained
- 1:09:37unauthorized access to the real systems
- 1:09:40of other organizations. By September,
- 1:09:43that count was up to four incidents
- 1:09:46found across a review of roughly 480
- 1:09:50million transcripts. So, apparently, the
- 1:09:53AI is not only writing your back end
- 1:09:55anymore. Sometimes, it's also trying to
- 1:09:58find its way out of the building.
- 1:10:01Obviously, these were very unusual
- 1:10:03evaluation environments with safety
- 1:10:05measures reduced for testing, not Claude
- 1:10:08code randomly attacking websites from
- 1:10:10someone's laptop. But, it does make one
- 1:10:12thing very clear. As AI starts writing
- 1:10:15more of your application, security
- 1:10:18matters even more. And there's another
- 1:10:20problem. Claude just helped us plan this
- 1:10:24database implementation. Claude wrote
- 1:10:27most of the code. Now, technically, I
- 1:10:30could ask Claude to check whether the
- 1:10:32code that it just wrote is secure, and
- 1:10:35it absolutely can find useful issues.
- 1:10:38But, for important security checks, I
- 1:10:41don't love the idea of having the same
- 1:10:44model that made the implementation
- 1:10:46decisions be the only model judging
- 1:10:49those same decisions afterward. I want
- 1:10:52another pair of eyes, and that's where I
- 1:10:54use Code Rabbit. They've sponsored this
- 1:10:57segment of the video to show you a
- 1:10:58feature that's especially useful at this
- 1:11:01stage. And it's called AI Deep Scan.
- 1:11:04Instead of only reviewing a single
- 1:11:06change, Deep Scan can inspect committed
- 1:11:09code across the repository and look for
- 1:11:12security risks across the application.
- 1:11:15And this is a good time to run it
- 1:11:17because we've just introduced our first
- 1:11:19real back-end and data layer. To be able
- 1:11:22to test it, we have to commit our work
- 1:11:24and push it over to GitHub. So, head
- 1:11:26over to github.com/new
- 1:11:29and create a new repository. I'll call
- 1:11:32an Atelier Store and I'll create it
- 1:11:34under my own profile. Once it is done,
- 1:11:37we can copy the URL and we can tell
- 1:11:39Claude to commit and push all the
- 1:11:42existing code to this GitHub repo. And
- 1:11:46it should be able to do that nicely for
- 1:11:48us, but we want to turn on the plan mode
- 1:11:51when we run that. And just switch over
- 1:11:53to auto mode.
- 1:11:54And I like how it's going to check
- 1:11:56whether the .env is not included as part
- 1:11:59of the push. While that is happening,
- 1:12:01you can head over to Code Rabbit by
- 1:12:03clicking the link in the description.
- 1:12:05You can start using it completely for
- 1:12:07free, but I've also got a special
- 1:12:09discount code for you. You can use JSMCR
- 1:12:13as the discount code, and the first 50
- 1:12:15new users will get Code Rabbit Pro Plus
- 1:12:18completely for free, which also gives
- 1:12:20you more deep scan runs for bigger, more
- 1:12:22ambitious projects. So, grab it while
- 1:12:25all those spots are available. But for
- 1:12:26now, let's go ahead and sign in using
- 1:12:29GitHub. Once you're there, you can
- 1:12:31connect a repository by adding it right
- 1:12:33here.
- 1:12:34In this case, I'm going to give it
- 1:12:35access to the specific repository, the
- 1:12:38Atelier Store, and I'll click install
- 1:12:41and authorize. Once it's there, you
- 1:12:43should be able to see it right here.
- 1:12:45Now, back on the VS Code side, as you
- 1:12:47can see, as per our rule, it's asking us
- 1:12:51whether we want to allow to push over to
- 1:12:53GitHub, which I'll say yes.
- 1:12:55It pushed over to main, so if you head
- 1:12:57over here, you should be able to see all
- 1:12:59your code right here.
- 1:13:01You can clean it up a bit by hiding the
- 1:13:03releases, deployments, and packages,
- 1:13:05giving it a short description such as a
- 1:13:07luxury brand storefront.
- 1:13:11We can enter the website. As soon as we
- 1:13:13deploy it, we'll be able to enter the
- 1:13:15real deployed URL. For now, I'll put the
- 1:13:17link to jsmasters.com.
- 1:13:19And here you can put something like
- 1:13:21Next.js, Cloud, or whatever else you
- 1:13:24want to add. Then head over to Code
- 1:13:26Rabbit.
- 1:13:27And under security, you can head over to
- 1:13:30AI Deep Scan. Currently, we have three
- 1:13:33deep scans, so let's scan a repository.
- 1:13:36In this case, we're going to pick the
- 1:13:38one that I chose. Some estimated credits
- 1:13:40are going to be right here, and then we
- 1:13:42can scan it. The scan has started, and
- 1:13:45we can see that right here.
- 1:13:47Now, there's one thing that I want to
- 1:13:48point out right here. And that is that
- 1:13:50I'm not going to intentionally introduce
- 1:13:52a vulnerability just so something
- 1:13:54dramatic appears on screen.
- 1:13:56I want to see what it finds in the
- 1:13:58application that we've genuinely built
- 1:14:00using Cloud. Deep Scan will look across
- 1:14:03a repository rather than only examining
- 1:14:06one isolated file or diff, so it can
- 1:14:09reason about how different parts of the
- 1:14:11application connect and surface security
- 1:14:13problems that may span several files.
- 1:14:17Now, let's give it some time until it
- 1:14:18finishes. Now, about 10 minutes in, the
- 1:14:21deep search is now complete. So, let's
- 1:14:24open it up and take a look at what it
- 1:14:26found. If we expand the scan details, we
- 1:14:29can see three findings. One medium, two
- 1:14:32low. No secrets were leaked, but under
- 1:14:35vulnerabilities, we can see three. And
- 1:14:38what's funny is that earlier I said that
- 1:14:40I wasn't going to plant a vulnerability
- 1:14:42just to have something dramatic on the
- 1:14:44screen, but it turns out I didn't need
- 1:14:47to. These are real findings in code that
- 1:14:51we genuinely built in this video. Don't
- 1:14:53just look at the count and panic, and
- 1:14:55don't automatically tell Claude to fix
- 1:14:58everything. We want to triage first.
- 1:15:00Let's start with the highest severity,
- 1:15:03and for each finding, decide is this
- 1:15:05real? Is it relevant? And does it need
- 1:15:08fixing now?
- 1:15:10The first finding is the weak secret.
- 1:15:14This medium finding right here says that
- 1:15:16the application accepts any better off
- 1:15:20secret without checking whether it's
- 1:15:22actually a strong secret. Now, why does
- 1:15:25that matter? Well, that secret signs
- 1:15:28authentication tokens. If a deployment
- 1:15:30ever uses something guessable there, an
- 1:15:33attacker can forge those tokens. And
- 1:15:36Code Rabbit even traced the specific
- 1:15:38path a forged change email verification
- 1:15:41token that ends with the attacker owning
- 1:15:44the victim's account.
- 1:15:45Notice what kind of finding this is.
- 1:15:47There is no bug in our code today. It's
- 1:15:50a missing guardrail, and it becomes a
- 1:15:52real vulnerability the day someone
- 1:15:54deploys this with a lazy secret.
- 1:15:56Exploitability right here is marked
- 1:15:58difficult, but the impact is account
- 1:16:01takeover, which is why it's the only
- 1:16:03medium in this list. And there's a bit
- 1:16:06of irony right here because our
- 1:16:08permission rules stopped Claude from
- 1:16:10ever reading the secret, but nothing in
- 1:16:13the application ever checked whether the
- 1:16:15secret is any good. So, let's bring this
- 1:16:17into Claude code.
- 1:16:19What you can do is just say fix right
- 1:16:21here, and if you have fixed enabled for
- 1:16:23this organization, Claude code will be
- 1:16:25able to automatically apply it. Else,
- 1:16:28you can just share this for agents, head
- 1:16:30over into Claude code by opening the
- 1:16:32terminal, and then pasting it in. It
- 1:16:35explains what the issue is,
- 1:16:38and specifies how to fix it. You can
- 1:16:41either pass it in like that or just tell
- 1:16:43it something like this. The application
- 1:16:46accepts any explicitly configured better
- 1:16:48auth secret. While the authentication
- 1:16:50dependency only warns about short or low
- 1:16:53entropy values. A guessable shared
- 1:16:55secret allows attackers to forge
- 1:16:57authentication-related tokens. And then
- 1:16:59we can ask it to investigate whether
- 1:17:01this is accurate for our own current
- 1:17:03better auth setup and explain the risk
- 1:17:05in the context of this application first
- 1:17:08without modifying anything yet.
- 1:17:10In your case, it's going to be enough if
- 1:17:12you just copy this and paste it in. But
- 1:17:14I want to investigate this first and
- 1:17:16then get back to you with more
- 1:17:17information on whether this really is
- 1:17:20that critical. And then if Claude
- 1:17:22confirms it, we can easily fix it. Very
- 1:17:24quickly, the answer is in. It told me
- 1:17:27that it traced this through the
- 1:17:28installed better auth source. The report
- 1:17:30is partly accurate. The mechanism is
- 1:17:32real, but its premise doesn't match this
- 1:17:34deployment and it understates one thing
- 1:17:37while oversaturating another.
- 1:17:39The mechanism is real. It found it. It
- 1:17:41means a session for the victim and
- 1:17:43rewrites their email. So anyone who
- 1:17:46knows the secret forges that token and
- 1:17:49takes that account over.
- 1:17:51One thing that the report gets more
- 1:17:52right than I'd guessed is that this
- 1:17:54branch never checks the option user
- 1:17:56change email enabled as that gate only
- 1:17:59exists on post change email.
- 1:18:01But that premise is wrong for us and the
- 1:18:03reality is worse.
- 1:18:05The report describes any explicitly
- 1:18:07configurable guessable secret and we
- 1:18:09don't have one. Better auth secret is
- 1:18:11present but empty. So create context
- 1:18:14falls through. That's a default secret,
- 1:18:17an exported constant in the
- 1:18:19in the published NPM package. It's
- 1:18:21publicly known. So this definitely is
- 1:18:24something to fix. We currently don't
- 1:18:26have any users, but as soon as we make
- 1:18:28this application live, this is a real
- 1:18:30risk. So let's simply tell it to fix it.
- 1:18:34And there Here go. The vulnerability is
- 1:18:36now fixed. Now, if the secret is unset,
- 1:18:39we'll get this result. If it's the
- 1:18:41default, we'll say that this is not
- 1:18:43good. If it's under 32 characters, we'll
- 1:18:45say must be at least 32. And if it's a
- 1:18:48repeated filler, well, we can also
- 1:18:50disqualify it. So, it'll only work if
- 1:18:53it's an OpenSSL randomized base 64
- 1:18:5632-character string. Perfect. So, let's
- 1:18:59generate one by heading over into a new
- 1:19:02terminal and run OpenSSL rand base 64.
- 1:19:06This will give you a string which we can
- 1:19:08now put into our .env under the better
- 1:19:11auth secret and it'll work. So, we can
- 1:19:14consider this one fixed. Now, the next
- 1:19:16finding is a low severity and honestly,
- 1:19:20I really like it.
- 1:19:21The home page has a newsletter sign up
- 1:19:23form. So, when Claude built that page
- 1:19:26back in the permission lesson, it
- 1:19:28scaffolded the form with the action
- 1:19:31hash.
- 1:19:32Something that looks like this.
- 1:19:35And it has no method.
- 1:19:37It's just placeholder code, but HTML has
- 1:19:40a default. A form without a method
- 1:19:43submits a get request, which means that
- 1:19:46every email address typed into that form
- 1:19:48gets appended to the URL. Into the
- 1:19:51address bar, the browser history, and
- 1:19:53our server logs. So, think about what
- 1:19:56just happened.
- 1:19:57AI-generated placeholder code sitting on
- 1:20:00the home page quietly leaking subscriber
- 1:20:02emails.
- 1:20:04I mean, nothing crashed per se, but this
- 1:20:06is exactly the kind of thing that an
- 1:20:08independent scan catches.
- 1:20:10And with a click of And if I took a
- 1:20:12quick glance, I would have missed it.
- 1:20:15So, I'm going to share this for agent.
- 1:20:17And then back into the Claude code
- 1:20:19terminal,
- 1:20:21we can just paste it and we'll tell it
- 1:20:23to fix it.
- 1:20:24Fix this, but before I run it, I also
- 1:20:27want to take a look at the next one.
- 1:20:30That's going to be the last one right
- 1:20:31here about information disclosure. And
- 1:20:34right now what's happening is that
- 1:20:36signing up with an email that already
- 1:20:37has an account returns a specific error
- 1:20:40while a new email succeeds. So, anyone
- 1:20:43can probe our sign-up endpoint and
- 1:20:45figure out which email addresses have
- 1:20:48accounts on this store.
- 1:20:50Is that a real issue? Yep. Is it
- 1:20:53critical for us today? Well, that is
- 1:20:55where you have to think instead of just
- 1:20:57auto fix it.
- 1:20:59The complete fix is requiring email
- 1:21:01verification so that every sign-up
- 1:21:03attempt looks identical from the
- 1:21:05outside.
- 1:21:06But, that needs an email sender which we
- 1:21:08deliberately kept out of this build for
- 1:21:10now. If you just add an email service
- 1:21:13onto this project right now mid-lesson
- 1:21:15just to close a low severity finding,
- 1:21:17well, that'll be exactly the kind of
- 1:21:19scope creep that we've been avoiding all
- 1:21:22this course. So, an honest engineering
- 1:21:24answer is that not every finding gets
- 1:21:27fixed the moment it appears. Some get
- 1:21:30fixed now like the one that I sent over
- 1:21:32Claude to fix. The first medium one and
- 1:21:35the second low severity one, but some
- 1:21:37will get a note that I will keep either
- 1:21:40in my mind or on a post-it next to me
- 1:21:42and then later on we can fix it. But,
- 1:21:45what you never want to do is just
- 1:21:47silently ignore it.
- 1:21:49Okay, so let's summarize what just
- 1:21:51happened here. Code Rabbit found three
- 1:21:53issues and explained exactly why each
- 1:21:56one matters. Claude then investigated
- 1:21:58each one inside the code base, confirmed
- 1:22:01them, and implemented the fixes.
- 1:22:04And you made the decision in between
- 1:22:06whether to fix now or document it for
- 1:22:09later. That's two independent systems
- 1:22:11and you are in the middle. It's a much
- 1:22:14healthier setup than just letting one
- 1:22:16model write the entire application and
- 1:22:18then asking it, is everything good? So,
- 1:22:20after it implemented, let's just go
- 1:22:22ahead and tell it to commit and push the
- 1:22:26changes.
- 1:22:27This will now be chained, so as soon as
- 1:22:29it is done, we'll be able to take a look
- 1:22:30at the code changes on GitHub. And
- 1:22:32alongside this, Code Rabbit also reviews
- 1:22:35pull request as code comes in. For
- 1:22:38bigger teams, there's also triage, which
- 1:22:41surfaces the changes that need attention
- 1:22:43first. So, go ahead and check out all
- 1:22:45that it does. I personally use Code
- 1:22:47Rabbit on jsmastery.com.
- 1:22:49That's our official platform repo, so I
- 1:22:52highly recommend it. The link is going
- 1:22:54to be in the description. But now, as
- 1:22:56we're pushing the final changes, I want
- 1:22:58to quickly continue where we left off.
- 1:23:00And if I remember correctly, that was
- 1:23:03the talk about context window and
- 1:23:05context wrought. In this case, we've
- 1:23:08been speaking with this particular agent
- 1:23:10for a long time.
- 1:23:13And sure, we still haven't filled out
- 1:23:15more than 20% of its context window, but
- 1:23:18I think it's about time that we reduce
- 1:23:20the clutter because we are done with
- 1:23:22fixing the security issues. So, there
- 1:23:24are two options. You can either use
- 1:23:27compact,
- 1:23:29which frees up the context by
- 1:23:30summarizing the conversation so far,
- 1:23:33or you can also run clear, which we have
- 1:23:36seen before. This Claude session did a
- 1:23:38lot, so let's go ahead and compact it.
- 1:23:41This will keep the useful parts of the
- 1:23:43current work while reducing the amount
- 1:23:45of conversation that Claude is carrying.
- 1:23:49It'll take some time, and then you'll
- 1:23:51still be able to continue on the same
- 1:23:52conversation but with less clutter. To
- 1:23:55be honest, I don't use compact as often.
- 1:23:59You only want to use this when you're
- 1:24:01working on the same work, but you need
- 1:24:03smaller context. But in most cases, when
- 1:24:06you fill up the context, you'll already
- 1:24:08be done with the feature implementing,
- 1:24:10so you can just run clear and start from
- 1:24:13a new session. And in this lesson, the
- 1:24:15thing that filled up the context was us
- 1:24:18using the plan mode to plan our entire
- 1:24:20database. But while we're compacting the
- 1:24:23conversation right here, I want to tell
- 1:24:25you to not use the plan mode for
- 1:24:28everything.
- 1:24:29If the task is something like change the
- 1:24:31heading or add more spacing here,
- 1:24:34just do it. Plan mode is useful when the
- 1:24:36approach itself needs to review.
- 1:24:39Things like the database changes,
- 1:24:41authentication, migrations, large
- 1:24:44refactors, or changes across several
- 1:24:47parts of the system.
- 1:24:48But, if the change is obvious, don't add
- 1:24:51another step just because the plan mode
- 1:24:52exists. And for more complex things,
- 1:24:55there's something on top of plan mode.
- 1:24:58Uh let me explain this in a read me
- 1:25:00right here. Plan mode works well when
- 1:25:02you already know what you want and
- 1:25:04Claude needs to figure out how to
- 1:25:06implement it.
- 1:25:07Something like add products, categories,
- 1:25:10and stock using Postgres and Drizzle.
- 1:25:13That's clear enough. But, something like
- 1:25:15build proper inventory management is
- 1:25:19much more vague.
- 1:25:20Does it mean multiple warehouses,
- 1:25:23reservations,
- 1:25:25low stock alerts,
- 1:25:28inventory history, or more?
- 1:25:30Well, that's where I separate the
- 1:25:32problem further inside of Agentic
- 1:25:34Engineering skills.
- 1:25:36As I told you already, it's an open
- 1:25:38source repo.
- 1:25:39And specifically, the skill in question
- 1:25:41right here would be the scope skill. So,
- 1:25:45head over here into scope just to show
- 1:25:47you.
- 1:25:48And what the scope skill does is to turn
- 1:25:51a product idea into a living core scope
- 1:25:54in the doc scope and keep it current.
- 1:25:57You can use it for planning a new
- 1:25:59product or a new slice, which would be a
- 1:26:01feature. You can use it to plan one
- 1:26:03feature specifically, or run it with no
- 1:26:06arguments to reconcile after shipping
- 1:26:08and queue what is next. So, basically,
- 1:26:10it's a seed for what to build.
- 1:26:14Then, there's also the architect skill,
- 1:26:16which works with you through the
- 1:26:17important technical decisions, and then
- 1:26:20the develop skill that builds. So,
- 1:26:22basically, we use the scope skill to
- 1:26:25challenge the idea before writing any
- 1:26:28code.
- 1:26:29Then, we use the architect skill, this
- 1:26:32one right here,
- 1:26:34to ask what important technical
- 1:26:36decisions need to be made. And finally,
- 1:26:39we can use the plan mode to check how
- 1:26:41should this specific change be
- 1:26:43implemented into the current code base.
- 1:26:46You don't need all of these at every
- 1:26:48step for every feature.
- 1:26:50But once you're working on larger
- 1:26:52applications, that separation becomes
- 1:26:54really useful. The workflow itself is
- 1:26:57completely free and open source, but if
- 1:26:59you want to learn how to use it with
- 1:27:00Claude Code,
- 1:27:02then you can check out the Agentic
- 1:27:04Engineering course.
- 1:27:05At this point, all the pieces you've
- 1:27:07learned are starting to work together.
- 1:27:09Claude and D keeps the important project
- 1:27:12rules.
- 1:27:13Permissions, right here, control what
- 1:27:15Claude can or must not do.
- 1:27:18Plan mode lets you review important
- 1:27:21changes before implementation. Compact
- 1:27:23helps when a long task starts filling
- 1:27:25the context. You can run context to see
- 1:27:29what is filling the context, and
- 1:27:31finally, the clear command gives you a
- 1:27:33fresh start when the new task is
- 1:27:35unrelated. That's the pattern you want
- 1:27:38to build.
- 1:27:39Knowing when each one is useful while
- 1:27:42you're actually building.
- 1:27:45At this point, you've already built
- 1:27:48several parts of our luxury storefront,
- 1:27:51and you're probably [clears throat]
- 1:27:52starting to notice something. The
- 1:27:54features change, but a lot of the
- 1:27:56process doesn't. When Claude builds
- 1:27:59another page, you still want it to
- 1:28:01inspect what already exists, reuse the
- 1:28:04design system, search for existing
- 1:28:07components, keep the page responsive,
- 1:28:09avoid unrelated changes, and verify what
- 1:28:12it built.
- 1:28:13You could keep writing all of that
- 1:28:15inside every prompt, or you can teach
- 1:28:18Claude that process once, and then reuse
- 1:28:20it.
- 1:28:21And that's what skills are for.
- 1:28:25A skill is a reusable procedure or piece
- 1:28:28of knowledge that Claude can load when
- 1:28:31it becomes relevant.
- 1:28:33At its simplest, a skill is a folder
- 1:28:35containing a skill.md file.
- 1:28:38Inside of that file, you describe what
- 1:28:41the skill does and how Claude should
- 1:28:43handle that kind of work. You can call a
- 1:28:45skill yourself with a forward slash,
- 1:28:47like build UI.
- 1:28:49Or Claude can use it automatically when
- 1:28:51your request matches what the skill is
- 1:28:54meant for.
- 1:28:55This is different from Claude.md,
- 1:28:57because your Claude or agents.md loads
- 1:29:00into every conversation for this
- 1:29:02project. But a skill loads its full
- 1:29:04instructions only when it's actually
- 1:29:07needed. So a detailed UI workflow
- 1:29:11doesn't take up context while you're
- 1:29:12debugging a database migration. So when
- 1:29:16should you write something into the
- 1:29:17Claude.md, or when should you invoke a
- 1:29:20skill? The answer is simple. Just ask
- 1:29:22yourself, is this a project fact, or is
- 1:29:26it a repeatable process? Use PNPM, use
- 1:29:30Drizzle, reuse the existing design
- 1:29:32system, those are facts, and they belong
- 1:29:35in Claude.md.
- 1:29:37But inspect the implementation, find
- 1:29:40reusable components, build the UI, check
- 1:29:42responsive behavior, run the app,
- 1:29:45verify, type check, summarize, is a
- 1:29:47process. Claude only needs it when doing
- 1:29:50that kind of work.
- 1:29:52That's a skill.
- 1:29:54So project fact goes into Claude.md,
- 1:29:57repeatable process is a skill, and a
- 1:29:59one-time task, well, just ask Claude.
- 1:30:02Anthropic specifically recommends skills
- 1:30:05when you keep repeating the same
- 1:30:06instructions or when something inside
- 1:30:09Cloud MD starts becoming a procedure
- 1:30:11rather than project context. And this is
- 1:30:13something that we go into a lot of
- 1:30:15detail about within the skills module of
- 1:30:18the course.
- 1:30:19Such as how to understand the skills,
- 1:30:21read them, build your own, and when you
- 1:30:24should use MCPs instead of skills as
- 1:30:26well.
- 1:30:27But let me tell you a bit about them
- 1:30:28here as well.
- 1:30:30Project skills live inside of the dot
- 1:30:32cloud folder and then within the skills
- 1:30:35folder.
- 1:30:36So, let me show you how to create a
- 1:30:37skill.
- 1:30:38Head over into dot cloud, create a new
- 1:30:41folder called skills, and then within
- 1:30:43skills create another folder called
- 1:30:46build-ui.
- 1:30:48And then within it, you can also create
- 1:30:50a new file called skill .md just like
- 1:30:54this.
- 1:30:55The directory name becomes the command.
- 1:30:59Build UI. Because this skill is specific
- 1:31:03to our store, keeping it inside of the
- 1:31:05project means you can commit it with the
- 1:31:07code and everyone gets the same
- 1:31:09workflow.
- 1:31:10A skill for all your projects would live
- 1:31:13not under this cloud folder, but under
- 1:31:15the cloud folder of your computer.
- 1:31:18Now, a skill has a YAML formatter and
- 1:31:21markdown instructions. And that looks
- 1:31:23something like this. You start with
- 1:31:25three dashes, then you give it a name
- 1:31:28such as build UI as well as a
- 1:31:31description. And here we can say
- 1:31:33something like build or update
- 1:31:37customer
- 1:31:38facing
- 1:31:40e-commerce UI
- 1:31:42using the existing design system
- 1:31:46components,
- 1:31:47product patterns, and responsive
- 1:31:51conventions.
- 1:31:52And here you also have to tell it when
- 1:31:54should it invoke it. So, we can tell it
- 1:31:56to use it when creating or significantly
- 1:31:59changing pages, sections, or customer
- 1:32:02facing components. Then, you close this
- 1:32:04header with three more dashes, and
- 1:32:07you're ready to write the body of a
- 1:32:08skill.
- 1:32:10In this case, we can say build or update
- 1:32:13the following UI.
- 1:32:14And skills can also accept arguments.
- 1:32:18You use the dollar sign, and then say
- 1:32:20arguments.
- 1:32:21So, we're asking it to build a UI off
- 1:32:24whatever we pass into it. So, we're
- 1:32:26telling it to build a UI off whatever
- 1:32:29they pass here.
- 1:32:30Arguments going to be filled in with
- 1:32:32whatever you type after the command. So,
- 1:32:34the skill carries over the process, and
- 1:32:36you only describe the feature. And then,
- 1:32:38we can give it some steps,
- 1:32:40such as inspect the current
- 1:32:41implementation and related components,
- 1:32:43search for reusable components before
- 1:32:45creating new ones, reuse the existing
- 1:32:47design system, and so on.
- 1:32:51Notice how we're not turning this
- 1:32:52skill.md into a huge manual. Rather, it
- 1:32:55is focused.
- 1:32:57If it eventually needs large references,
- 1:32:59materials, or scripts, those can be
- 1:33:01moved into separate files within the
- 1:33:03build UI folder. And the part that
- 1:33:06matters much more than it looks like is
- 1:33:09the description.
- 1:33:10The description isn't just documentation
- 1:33:12for you.
- 1:33:13It's how Claude decides whether this
- 1:33:16skill is relevant.
- 1:33:18Claude reads the names and descriptions
- 1:33:20of available skills, and matches them
- 1:33:23against your request.
- 1:33:25If you give it a description of useful
- 1:33:28UI workflow, well, that basically tells
- 1:33:31it nothing. But if you specify it like
- 1:33:33this, that tells Claude what the skill
- 1:33:36does and when to use it.
- 1:33:38So, a weak description is going to be
- 1:33:40the main reason that a skill doesn't
- 1:33:42trigger when you expect it to. So, now,
- 1:33:45instead of that same long checklist, we
- 1:33:48can just open up Claude and tell it
- 1:33:51/build
- 1:33:53UI,
- 1:33:54which is going to build or update
- 1:33:55customer-facing e-commerce UI using the
- 1:33:58existing design system components and so
- 1:34:00on. And then we can tell it build a new
- 1:34:04arrivals
- 1:34:05page using the latest
- 1:34:08products
- 1:34:09from the database.
- 1:34:12Keep it consistent with the home page
- 1:34:15product listing and product detail pages
- 1:34:20already in the application.
- 1:34:23Perfect.
- 1:34:24Now that we have the skill, it's much
- 1:34:26easier as we don't have to have such
- 1:34:28detailed and accurate prompts.
- 1:34:31So, let's see how it approaches it. And
- 1:34:33I'm running it with auto mode on. And
- 1:34:36there we go. In a couple of minutes, the
- 1:34:38new arrivals is now live and reachable
- 1:34:41from Chrome. It added a new page, server
- 1:34:44components, breadcrumbs, hairline rule,
- 1:34:47empty states with no new colors,
- 1:34:49classes, or components.
- 1:34:51So, we can explore it on localhost:3000.
- 1:34:54Back in the browser, we can browse our
- 1:34:56existing collections or product pages,
- 1:34:59or you can head over into this new in at
- 1:35:02the top left and see what seems to be a
- 1:35:05category page sorted by the newest
- 1:35:08pieces right here. It did it incredibly
- 1:35:11well, and of course, even from here, you
- 1:35:13can visit a specific product page.
- 1:35:16And if you take a closer look at how it
- 1:35:18did it, Claude simply loaded the skill
- 1:35:21and inspected the existing
- 1:35:22implementation. You can see that right
- 1:35:24here. Skill loaded successfully.
- 1:35:27And then it searched for one pattern,
- 1:35:29read three files, listed one directory,
- 1:35:31and only then did it start with the
- 1:35:33implementation.
- 1:35:35So, the skill follows the workflow, but
- 1:35:38we only described what we are building.
- 1:35:41And it's completely reusable. You can
- 1:35:44also tell it to do something else, such
- 1:35:45as build UI, add a category collection
- 1:35:48page, and let's see how quickly and how
- 1:35:51well does it do that. And just like
- 1:35:54that, again, in about 2 minutes, it
- 1:35:56added a new page.
- 1:35:58So, back in the browser, we can test it
- 1:36:01out by heading over to a specific
- 1:36:03collection, like going to maybe
- 1:36:06sunglasses, and then right here using
- 1:36:08breadcrumbs, you can head over to
- 1:36:10eyewear. And you'll see that we have
- 1:36:12three pieces belonging to eyewear right
- 1:36:14here. You can also browse other things
- 1:36:17such as leather goods, and I can notice
- 1:36:19that we still have to connect it from
- 1:36:21our navigation bar, but right now we can
- 1:36:23navigate over from the collections part.
- 1:36:25So, you can see we have leather, we have
- 1:36:28eyewear, there's jewelry as well. So,
- 1:36:31you can see that now we have full-on
- 1:36:33product categories. And that was pretty
- 1:36:35simple to build, right? This was the
- 1:36:37same process as running the initial
- 1:36:40prompt, just on a different feature.
- 1:36:42And this is where skills become much
- 1:36:44more useful than saving prompts
- 1:36:46somewhere. You're turning the way you
- 1:36:47work into something reusable. And that's
- 1:36:50exactly why I've built the agentic
- 1:36:52engineering workflow I mentioned at the
- 1:36:54start of the video. What you just did
- 1:36:56with the build UI skill is the same idea
- 1:36:59applied to the entire engineering
- 1:37:02workflow. Instead of repeatedly telling
- 1:37:03an AI to inspect the project, decide
- 1:37:06what should be built,
- 1:37:08make the technical decisions, develop
- 1:37:10the features,
- 1:37:12verify them, test them, check them,
- 1:37:14review them, and keep the project
- 1:37:16context updated with sync, each one of
- 1:37:18those becomes a reusable skill. Scope is
- 1:37:22the first one. It figures out what
- 1:37:25should actually be built. Then, there's
- 1:37:27the audit, which studies what already
- 1:37:30exists.
- 1:37:31Architect works through the important
- 1:37:33technical decision. Develop
- 1:37:36implements the feature. Check simply
- 1:37:38verifies or reviews the work.
- 1:37:42Test handles testing. Document updates
- 1:37:45documentation. Sync keeps the project
- 1:37:48context up to date, and debug gives you
- 1:37:51a proper debugging process instead of
- 1:37:53letting it randomly change files until
- 1:37:55something works. The workflow is
- 1:37:57completely free and open source, and
- 1:38:00because it's built on skills, it works
- 1:38:02with Claude Code, Cursor, Codex, or any
- 1:38:04other agent.
- 1:38:06And on top of it, the Agentic
- 1:38:08Engineering course is where I show you
- 1:38:10how to use all of it properly on larger
- 1:38:12applications, legacy codebases, and
- 1:38:15monorepos. Both links are going to be in
- 1:38:17the description in case you want to
- 1:38:19check it out. But to get back to skills
- 1:38:21briefly, I want to tell you that you
- 1:38:23don't always have to manually type
- 1:38:25buildUI or any other skill name. If you
- 1:38:28properly wrote the name of the skill and
- 1:38:31its description,
- 1:38:32running something like add a new
- 1:38:34arrivals page using the current design
- 1:38:36system should be enough because Claude
- 1:38:39can see the skill description, recognize
- 1:38:41the match, and load it automatically.
- 1:38:43And that's one of the major differences
- 1:38:45between skills and older custom {slash}
- 1:38:48commands, user invoked versus model
- 1:38:51invoked. But you don't always want both.
- 1:38:54Imagine you create something like a
- 1:38:56deploy skill or a commit skill.
- 1:38:59Those have real side effects, and you
- 1:39:02probably don't want Claude deciding on
- 1:39:04its own, everything looks ready, I'll
- 1:39:06deploy it.
- 1:39:07So for workflows like that,
- 1:39:09you can head over to that specific
- 1:39:11skill,
- 1:39:12and you can modify its front matter
- 1:39:16with an additional line, disable model
- 1:39:19invocation set to true.
- 1:39:21Now only you can trigger it manually.
- 1:39:24And another reason why skills scale
- 1:39:26better than simply stuffing Claude MD is
- 1:39:29how they load.
- 1:39:31There are three layers.
- 1:39:33First, Claude sees the metadata, which
- 1:39:36is the name and the description. When
- 1:39:38the skill becomes relevant, it loads the
- 1:39:40skill MD file. And if the skill has
- 1:39:43extra references right here in the same
- 1:39:45folder, for example, scripts or
- 1:39:47examples, we can load those only when
- 1:39:50necessary. So, the main skill MD doesn't
- 1:39:53need the entire design system inside it.
- 1:39:55It can point Claude to something like
- 1:39:57references design system MD whenever
- 1:40:00deeper guidance is needed. Anthropic
- 1:40:02calls this progressive disclosure. If
- 1:40:05you take a look at the skills of the
- 1:40:06agentic engineering workflow, and
- 1:40:08specifically the scope or architect
- 1:40:10skills, you can see that alongside the
- 1:40:13skill MD, there's so much more stuff
- 1:40:15right here. Such as the scope template
- 1:40:18that it can read whenever it needs to.
- 1:40:20The modes, such as the brownfield
- 1:40:23project, greenfield project, plan,
- 1:40:26replan, and more.
- 1:40:27Three different development approaches,
- 1:40:29facade, journey, skateboard, and tracer
- 1:40:31bullet, which are actual software
- 1:40:33development workflows to follow when
- 1:40:35building applications, as well as the
- 1:40:37YAML file right here.
- 1:40:40All of those are part of a larger skills
- 1:40:43setup. And in the course, we go a bit
- 1:40:45deeper into how to build your own skill.
- 1:40:48Oh, and another pro tip is that you
- 1:40:50don't have to write every skill MD by
- 1:40:51hand. Anthropic has something called a
- 1:40:54skill creator workflow that builds and
- 1:40:57improves skills through conversation.
- 1:40:59And it can even run evaluation cases
- 1:41:01with and without the skill to check
- 1:41:03whether it actually improves Claude's
- 1:41:05behavior. Because a skill that sounds
- 1:41:07good isn't necessarily a skill that
- 1:41:10works. So, test it. You can run it
- 1:41:12easily by running the skill creator
- 1:41:14skill and tell it what skill you want to
- 1:41:16create. Another pro tip is to not turn
- 1:41:19this Claude skills folder into a mess.
- 1:41:23Every skill adds metadata that Claude
- 1:41:25has to consider.
- 1:41:2710 useful skills are fine, but 100
- 1:41:29random ones aren't. There's also a
- 1:41:32custom skill called skill doctor, which
- 1:41:35can show you which loaded skills are
- 1:41:37unused and costing context. That way,
- 1:41:41you can just delete them.
- 1:41:43And also, be careful with the skills you
- 1:41:45download. They can contain scripts,
- 1:41:48command executions, and tool access. So,
- 1:41:51read the skill.md and any scripts before
- 1:41:53installing. Whenever you do try to
- 1:41:55install them, you'll also get some
- 1:41:57information on whether they might
- 1:41:58include something sketchy. If we install
- 1:42:01my own skills right here by exiting the
- 1:42:05Claude and MPX skills latest js mastery
- 1:42:08pro skills, you'll need to install the
- 1:42:10skills package. Select which skills to
- 1:42:13install.
- 1:42:14You can do them either on a project or a
- 1:42:16global basis. And you can see that here
- 1:42:19you'll see that most of them are safe.
- 1:42:21And for some reason, if something got
- 1:42:22changed in the meantime, maybe some are
- 1:42:24going to be medium or high risk or some
- 1:42:27are going to be like, "Please don't
- 1:42:28install them." But I can assure you that
- 1:42:31these skills are more than safe. And
- 1:42:33yeah, the last pro tip would be to try
- 1:42:36not to design the perfect skill on day
- 1:42:39one.
- 1:42:40Rather, use it. Watch where Claude still
- 1:42:43makes mistake and then fix that skill.
- 1:42:46Add some kind of a missing rule or
- 1:42:48sharpen the verification step. Fix a
- 1:42:50description that triggers it whenever
- 1:42:52you need it and not at the wrong times.
- 1:42:54Skills improve from the actual usage.
- 1:42:58So, by this point, you've already moved
- 1:43:00beyond giving Claude some random
- 1:43:02individual prompts.
- 1:43:04Your Claude MD now keeps the rules that
- 1:43:07should always be available. Permissions
- 1:43:09control what Claude can do. Plan mode
- 1:43:12reviews the approach before the
- 1:43:13implementations. And skills can give you
- 1:43:16reusable workflows that load only when
- 1:43:19needed.
- 1:43:20The next step is what happens when one
- 1:43:22Claude session doesn't need to do every
- 1:43:25part of the work itself.
- 1:43:27So, let's work on that next.
- 1:43:31At this point, you've learned quite a
- 1:43:33few Cloud Code features individually.
- 1:43:36Cloud MD for project context,
- 1:43:38permissions for control, plan mode for
- 1:43:41expensive decisions, and your own skills
- 1:43:44for repeatable processes.
- 1:43:46And our storefront looks like a real
- 1:43:49store now.
- 1:43:50But you still can't actually buy
- 1:43:53anything.
- 1:43:54We're missing authentication, a cart,
- 1:43:57stock enforcement, checkout orders, and
- 1:44:00the customer account. But here's the
- 1:44:02thing.
- 1:44:03Building all of that is the exact same
- 1:44:06loop you've already learned over and
- 1:44:09over. Describe the feature,
- 1:44:12plan when the decision is expensive, and
- 1:44:15let Cloud build, review, and verify it.
- 1:44:18So, I'm not going to build it at you.
- 1:44:21This is your assessment.
- 1:44:24You're going to ship the rest of the
- 1:44:25store yourself, and I'll give you
- 1:44:27everything you need. Every prompt in
- 1:44:30order in the free resources linked
- 1:44:32below.
- 1:44:33But before you start, let me show you
- 1:44:35three things that make this assessment
- 1:44:38much easier. Because you don't have to
- 1:44:40do all of it with plain prompts. First,
- 1:44:43the UI. You already built the build UI
- 1:44:47skill in the last lesson.
- 1:44:49The cart page, the account overview,
- 1:44:51order history, those are exactly what
- 1:44:54the skill is for.
- 1:44:55So, you can just use the build UI skill
- 1:44:58and tell it to build the cart page, or
- 1:45:03build the account overview.
- 1:45:05It is the same process, just a different
- 1:45:08feature. And that's the whole point of
- 1:45:10encoding your workflow into a skill.
- 1:45:12This assessment will reuse it. But
- 1:45:15second, you're going to have to work on
- 1:45:17authentication. You could prompt it from
- 1:45:20scratch,
- 1:45:21but remember how skills work.
- 1:45:24They don't have to come from you.
- 1:45:26Libraries, such as BetterAuth, can
- 1:45:29publish skills that teach agents how
- 1:45:31their APIs and workflows are supposed to
- 1:45:34be used.
- 1:45:36So, BetterAuth does exactly that, so we
- 1:45:38can install their skills.
- 1:45:40Back within our application, you can
- 1:45:42open up a new terminal window and run
- 1:45:44MPX skills add BetterAuth skills, like
- 1:45:48this.
- 1:45:49It'll then ask you which skills you want
- 1:45:51to install. You can install some
- 1:45:52additional ones or just the core auth
- 1:45:55skills, which I'll select. I'll select
- 1:45:57it for my Claude code.
- 1:46:00Press enter a few more times and they're
- 1:46:02going to get installed immediately.
- 1:46:04That'll install BetterAuth's official
- 1:46:06skill pack. And you can even see that
- 1:46:08right here, how we have our own skill,
- 1:46:11we now also have this agents folder,
- 1:46:13within it we have skills, and then there
- 1:46:16are two skills. One is called create
- 1:46:18auth and the other one is called
- 1:46:20BetterAuth best practices.
- 1:46:22Now that you know how to create your own
- 1:46:23skill, you also should understand how
- 1:46:26some other people or companies can
- 1:46:29create their own skills maintained by
- 1:46:32the developers who build a library and
- 1:46:34instead of hoping Claude remembers
- 1:46:36exactly how the latest version works,
- 1:46:38the maintainers give your agent
- 1:46:41instructions directly. And the habit
- 1:46:43from the last lesson still applies. A
- 1:46:46skill can contain instructions, scripts
- 1:46:49and tools. These come from BetterAuth
- 1:46:51itself, but always look at what you just
- 1:46:54gave your agent. For example, make sure
- 1:46:56that the skill will actually get
- 1:46:58executed based on your prompt. Oh, and
- 1:47:00one more tip when you do the auth part
- 1:47:02of the assessment. Run it in plan mode
- 1:47:05first. Authentication touches the
- 1:47:07database, sessions, protected routes and
- 1:47:10customer data, which is exactly what
- 1:47:12kind of change the plan mode is for.
- 1:47:14And I'll leave the exact planning prompt
- 1:47:16in the resources down below. On top of
- 1:47:18the skills that we have built and the
- 1:47:21skills that you going to install,
- 1:47:22there's also a third thing called
- 1:47:25plugins.
- 1:47:27In the same way that specific tools can
- 1:47:29create their own skills, some more
- 1:47:31well-established tools can publish
- 1:47:33official Claude plugins.
- 1:47:36The Stripe plugin, for example, which
- 1:47:38we'll have to use for checkout, allows
- 1:47:40Claude to connect to Stripe's MCP
- 1:47:42server, enabling AI-assisted payment
- 1:47:45integration development.
- 1:47:46As a skill, it provides everything that
- 1:47:48a skill does, such as best practices,
- 1:47:51guidance for implementing checkout
- 1:47:53flows, subscriptions, and more, as well
- 1:47:55as more on top of it, such as helping
- 1:47:57you avoid deprecated APIs and follow
- 1:48:00Stripe's recommended patterns.
- 1:48:02So, you can very easily install it by
- 1:48:04copying this installation command.
- 1:48:07You can do that in the terminal by
- 1:48:09running Claude plugin install
- 1:48:11stripe@claude-plugins-official.
- 1:48:14And just press enter. It'll ask you
- 1:48:16whether you want to install the plugin,
- 1:48:18and very soon it'll be installed.
- 1:48:21So, now if you run Claude,
- 1:48:24and you run {forward slash} plugins,
- 1:48:27you'll be able to see which plugins you
- 1:48:29might have installed before. I have a
- 1:48:31couple, but in this case, we are looking
- 1:48:33for the Stripe plugin, which might
- 1:48:36already be under installed. There we go.
- 1:48:40You just need to press enter to
- 1:48:41authenticated from Stripe. So, go ahead
- 1:48:44and press authenticate, and it'll be
- 1:48:46opened in a new browser window, where
- 1:48:48you'll have to sign into your Stripe
- 1:48:50account. Then, you'll have to enable
- 1:48:53your MCP.
- 1:48:54I'll do it for the test environment and
- 1:48:56give it all the necessary permissions
- 1:48:58and authorize.
- 1:49:00And that's it. You can now close this
- 1:49:02tab and return to Claude Code.
- 1:49:05And just like that, you have
- 1:49:06successfully authenticated your plugin.
- 1:49:09So, now you know not only how to create
- 1:49:11your own skills, but install other
- 1:49:13people's skills, as well as plugins.
- 1:49:16There's one small distinction between
- 1:49:18the two. You can think of a skill as a
- 1:49:20one reusable process, whereas a plugin
- 1:49:23is a package that can include skills as
- 1:49:26well as other Cloud Code capabilities,
- 1:49:29such as MCPs.
- 1:49:31And you can also browse what's installed
- 1:49:33with the {forward slash} plugin command.
- 1:49:36And same rule as always applies, don't
- 1:49:38install random plugins. They can contain
- 1:49:42much more than markdown, so trust where
- 1:49:44they come from. So now you have
- 1:49:47everything you need. Your BuildUI skill
- 1:49:49for the pages, Better Auth community
- 1:49:51skills for authentication, and Stripe's
- 1:49:53official plugin for the checkout.
- 1:49:56The full assessment is in the free
- 1:49:58resource linked below.
- 1:50:00It contains a couple of prompts in order
- 1:50:02from authentication all the way to the
- 1:50:04customer accounts. So build it, break
- 1:50:07it, fix it, use the plan mode where the
- 1:50:09decision is expensive, and skip it where
- 1:50:12it isn't.
- 1:50:13And that's where everything from this
- 1:50:14course actually becomes yours.
- 1:50:17If you're just following along, you're
- 1:50:19not learning as much.
- 1:50:21But now that you've been watching this
- 1:50:22video for more than an hour, it's time
- 1:50:24for you to actually give it a shot.
- 1:50:27And when you're done, tell me in the
- 1:50:29comments how it went. I do read all of
- 1:50:31the comments.
- 1:50:33Pause this video, do it, and then let's
- 1:50:35continue together. So, how did it go?
- 1:50:38After I ran a couple of these prompts,
- 1:50:41the last step was to create and hook up
- 1:50:44my Stripe account. Thankfully, that was
- 1:50:47easy thanks to the Stripe package and
- 1:50:49the CLI. So I was more or less able to
- 1:50:52do it directly to the terminal, but I
- 1:50:54simply got the Stripe secret key and
- 1:50:56added it to the ENVs, so Cloud doesn't
- 1:50:58have access to it. With that in mind,
- 1:51:01our application now not only looks good,
- 1:51:04but has a real database and a real
- 1:51:07checkout where we can actually buy
- 1:51:09stuff.
- 1:51:10So let me add this to a bag. You can see
- 1:51:13that now we can sign in. So, this is a
- 1:51:15beautiful looking sign in page, which
- 1:51:17looks exactly as I would expect it from
- 1:51:20a luxury storefront. So, let me go ahead
- 1:51:23and enter my contact information. In
- 1:51:25this case, of course, we can't sign in
- 1:51:27because we never created an account, but
- 1:51:29let's go ahead and create one.
- 1:51:32I'll call myself JS Mastery.
- 1:51:35And I'll create a new account.
- 1:51:39There we go. Looks like we are now
- 1:51:41signed in successfully. So, we can go
- 1:51:43ahead and add some items to the cart.
- 1:51:46Let's go ahead and add this uh Bordeaux
- 1:51:48croc embossed flap bag, close to 3,000
- 1:51:52bucks.
- 1:51:53As well as let's try to add something
- 1:51:56else, maybe these sunglasses right here
- 1:52:00or this card holder. Let's go with Oh,
- 1:52:02it's sold out. This is nice. So, the
- 1:52:04sold out functionality works as well.
- 1:52:07And you can see that there's email me
- 1:52:09when it returns functionality, which we
- 1:52:10can implement later on as well.
- 1:52:13Let's go with this backpack.
- 1:52:15Okay, we have added those two to the bag
- 1:52:18and you can now see how that looks like.
- 1:52:20Only to modify the design slightly, so
- 1:52:22it looks a bit better, but let's try to
- 1:52:25proceed to the checkout. This actually
- 1:52:27opens up a complete Stripe checkout in
- 1:52:31sandbox mode. And oh my god, I would
- 1:52:34never pay close to 5,000 bucks for a bag
- 1:52:38and a backpack. But thankfully, I can
- 1:52:40use my test card right here by just
- 1:52:42pressing the letters four and two one
- 1:52:45after another. And with that, we can now
- 1:52:47pay.
- 1:52:48In about a minute, it looks like it's
- 1:52:50exceeded and we can see a thank you
- 1:52:52page.
- 1:52:53Of course, the next natural steps would
- 1:52:55be to take a screenshot of this page
- 1:52:57right here that says thank you, as well
- 1:53:00as of the other pages that we have seen,
- 1:53:02which don't look as good and then fix
- 1:53:05the UI of them. But that will be super
- 1:53:08simple. Like, I can remain on this page
- 1:53:10right now, head over to the code, and
- 1:53:12then simply drag and drop the photo
- 1:53:15while holding the shift key,
- 1:53:17and then tell it
- 1:53:18the design seems off. Improve the UI of
- 1:53:25the thank you page.
- 1:53:28And we can say use front-end skills.
- 1:53:32This should take about a minute, and
- 1:53:33then without reloading, we should be
- 1:53:36able to see this page get to its proper
- 1:53:38look to match the rest of this beautiful
- 1:53:40design. And it looks like it found it
- 1:53:43pretty quickly. It'll load the design
- 1:53:44skill before reworking the page and fix
- 1:53:47it. And in about a minute, this is much
- 1:53:51much better.
- 1:53:52Or should I say much worse because now I
- 1:53:54can more clearly see this huge amount
- 1:53:57that was spent, well, thankfully on my
- 1:53:59testing account. But, yeah, as you can
- 1:54:01see, with the right tools and the right
- 1:54:03process, I didn't even have to tell you
- 1:54:05how to fix this because I've taught you
- 1:54:07the process of developing on your own.
- 1:54:10And believe it or not, this is it. We
- 1:54:13have successfully implemented the full
- 1:54:15functionality for logging in, for adding
- 1:54:17the items of the cart, as well as
- 1:54:20purchasing the items for our account
- 1:54:23through our Atelier store. Wonderful.
- 1:54:26And these items are also getting
- 1:54:29updated, so you can see since we added
- 1:54:31this backpack, maybe this one has more
- 1:54:33items in stock, but if we take a look at
- 1:54:35this one, this one only has three left.
- 1:54:39So, yeah, the store is officially done.
- 1:54:42You can go ahead and play with the
- 1:54:43design a bit more, fix a couple of those
- 1:54:45pages that didn't look as good, or
- 1:54:47modify this hero section, or center the
- 1:54:50items in the navigation bar. At least
- 1:54:52that's something that I would do if I
- 1:54:53was continuing to develop this
- 1:54:55application further. But, now that we
- 1:54:57have a fully functional e-commerce
- 1:54:59store, somebody still has to run it.
- 1:55:02There's no place to create products, to
- 1:55:05update the inventory, or manage orders.
- 1:55:08We need an admin side. So, in this
- 1:55:11video, I'll teach you how to do that,
- 1:55:13too. And keep in mind that that admin
- 1:55:15side touches almost everything.
- 1:55:18It touches the database, which we
- 1:55:20haven't opened in some time. So, now
- 1:55:22would be a good time if you head over
- 1:55:24into tables, you can see the exact
- 1:55:27number of items that we have for each
- 1:55:30specific product. You can see that these
- 1:55:33two are low in stock, and for now we can
- 1:55:37update the stock manually like this.
- 1:55:39But, we don't really want to do that. We
- 1:55:41want to do that through an admin system
- 1:55:43that touches the database,
- 1:55:45authentication, products, inventory,
- 1:55:47orders, and all of that. Now, Claude
- 1:55:49could investigate all of that inside of
- 1:55:52our main conversation, but it would fill
- 1:55:54the same context that we need to use for
- 1:55:57building. And that's where the sub
- 1:55:59agents come in. So, let me teach you a
- 1:56:01bit about them in the next lesson.
- 1:56:05The customer side of our store is now a
- 1:56:09pretty good place. A customer can browse
- 1:56:12products, search, create an account, add
- 1:56:14products to cart, check out, place an
- 1:56:16order, or see their order history.
- 1:56:19But, somebody still has to actually run
- 1:56:23the store.
- 1:56:24We need an admin side where someone can
- 1:56:27create and edit products, manage
- 1:56:29categories, update the inventory, see
- 1:56:32the orders, or update the order status.
- 1:56:35And this is where our application has
- 1:56:38finally become large enough that another
- 1:56:40Claude code feature becomes genuinely
- 1:56:43useful.
- 1:56:44Because before Claude builds the admin
- 1:56:46side, it needs to understand quite a few
- 1:56:49different areas of the application.
- 1:56:51Authentication, products, database
- 1:56:54schema, inventory, orders, existing UI
- 1:56:57patterns.
- 1:56:58Claude could research all of that inside
- 1:57:01of the main conversation. But then all
- 1:57:03of those file reads, searches, and
- 1:57:05intermediate findings would fill the
- 1:57:07same context we're about to use to
- 1:57:10actually build the feature. And that's
- 1:57:13where the sub-agents come in.
- 1:57:15A sub-agent is another Claude agent that
- 1:57:18receives a focused task and works on it
- 1:57:22inside of its own context.
- 1:57:25The main Claude delegates the task, the
- 1:57:28sub-agent investigates it, and then
- 1:57:31reports the important result back.
- 1:57:34So, instead of your main conversation
- 1:57:36carrying every file and every search the
- 1:57:39sub-agent needed, you mainly get back
- 1:57:42the useful findings.
- 1:57:44That's the real value. Sub-agents give
- 1:57:47you context isolation.
- 1:57:49They're not magically smarter versions
- 1:57:51of Claude. They're only useful because
- 1:57:54some work can happen separately. And
- 1:57:57don't think of them as AI employees
- 1:58:00because this is where sub-agents
- 1:58:02sometimes get over complicated.
- 1:58:04People create things like senior staff
- 1:58:07back-end engineer or elite security
- 1:58:10architect, world-class React expert. But
- 1:58:13Claude doesn't suddenly gain new
- 1:58:16knowledge because you gave the context
- 1:58:17window a fancy job title.
- 1:58:20The better question is, what work can
- 1:58:23happen separately that my main
- 1:58:25conversation doesn't need to carry? For
- 1:58:28our admin application, that's pretty
- 1:58:30obvious. Before implementing anything,
- 1:58:33we need several independent
- 1:58:35investigations. So, let's delegate them.
- 1:58:39Now, tell the main Claude something like
- 1:58:42this.
- 1:58:43Before building the admin side of our
- 1:58:45project, investigate the existing
- 1:58:48application using separate focused
- 1:58:51sub-agents.
- 1:58:52Have independently inspect the products,
- 1:58:55categories, and the current Drizzle data
- 1:58:57model, stock and inventory behavior,
- 1:59:01authentication and safest minimal way to
- 1:59:03add admin access, orders and the current
- 1:59:06order life cycle, existing UI patterns
- 1:59:09so we can reuse.
- 1:59:10Each subagent should return the current
- 1:59:12behavior, relevant files, important
- 1:59:15constraints, and a recommended approach.
- 1:59:18Do not implement anything yet. Combine
- 1:59:21their findings into one concise summary
- 1:59:23when they're done. Run it, and now watch
- 1:59:26Claude do its work. It'll dispatch five
- 1:59:29focused investigators in parallel.
- 1:59:32This is a good example of a parallel fan
- 1:59:35out. None of these agents need an answer
- 1:59:38from another agent before beginning
- 1:59:40their investigation.
- 1:59:42Rather, they can independently explore
- 1:59:44the parts of the code base and then
- 1:59:46report back.
- 1:59:48One is investigating the data model.
- 1:59:51Another is investigating the stock
- 1:59:52behavior. And another investigating off
- 1:59:56and admin access. And another
- 1:59:58investigating order life cycle. And the
- 2:00:01last one is investigating the UI
- 2:00:05patterns.
- 2:00:06The main model is not doing anything. It
- 2:00:09is waiting for all the findings to come
- 2:00:11back, and then it'll combine their
- 2:00:13findings into one summary, and then you
- 2:00:15can do something with it. A beautiful
- 2:00:17example of a parallel fan out. So, let's
- 2:00:21give it some time to run. You can see
- 2:00:23for how long each one of these has been
- 2:00:25running, and how many tokens is it
- 2:00:27spending.
- 2:00:28Even though it might seem like it's a
- 2:00:30lot of tokens, you would spend more
- 2:00:32tokens and more time if you just let one
- 2:00:35agent do the thing. This way, the work
- 2:00:37is being done five times as fast. One
- 2:00:41already finished after a minute and 20
- 2:00:43seconds. And we're waiting for the four
- 2:00:46other ones to finish as well.
- 2:00:48You can switch to another model to see
- 2:00:50what it is doing at any time
- 2:00:53or simply get back to the main.
- 2:00:55Four in, one to go. The UI patterns
- 2:00:58agent is still working.
- 2:01:00And that one reported, too. All five
- 2:01:02investigations are complete and here are
- 2:01:05the combined findings. We can see
- 2:01:07everything we need to know about our
- 2:01:08data model,
- 2:01:09about the stock, how there are four
- 2:01:11states,
- 2:01:13the constraints about it as well, the
- 2:01:15auth and the admin access, the
- 2:01:17recommendation on how to approach
- 2:01:19authentication for the admin panel, and
- 2:01:21then there's orders, how we can keep
- 2:01:23track of them or increase the number of
- 2:01:26items, and then there are UI patterns
- 2:01:29that follow this editorial luxury system
- 2:01:32entirely stored in globals.css.
- 2:01:35There are some cross-cutting themes and
- 2:01:37an important decision to consider before
- 2:01:39proceeding. That's it.
- 2:01:42This took 3 minutes exactly,
- 2:01:44but it did more than 15 minutes at work.
- 2:01:47So, why didn't we just let the main
- 2:01:49Claude read everything? Just imagine the
- 2:01:51product investigation reads 10 files,
- 2:01:53auth 3 reads another eight, and orders
- 2:01:56reads another 12, and then UI
- 2:01:58exploration reads another 10.
- 2:02:01The main Claude may only need a few
- 2:02:03important conclusions from each
- 2:02:05investigation before it can build a
- 2:02:07feature.
- 2:02:08Sub agents let all that exploration
- 2:02:10happen somewhere else.
- 2:02:13The main conversation gets the useful
- 2:02:15result without carrying the entire
- 2:02:17journey.
- 2:02:18And that's the whole point. And you may
- 2:02:21have already seen Claude delegate work
- 2:02:23automatically. I mean, Claude code
- 2:02:26includes built-in agents for different
- 2:02:28kinds of jobs. For example, explore,
- 2:02:31plan, or general-purpose. Explore is
- 2:02:34useful for read-only code-based
- 2:02:36investigation, plan helps with research
- 2:02:39during planning, and general-purpose can
- 2:02:41handle, well, as it says,
- 2:02:43general-purpose tasks.
- 2:02:45But, you don't always need to wait for
- 2:02:48Claude to decide.
- 2:02:50You can simply say, "Use an explore
- 2:02:53sub-agent to inspect how admin
- 2:02:55authorization should fit into the
- 2:02:58current better auth implementation."
- 2:03:00Or something like, "Delegate the order
- 2:03:03life cycle investigation to a separate
- 2:03:06sub-agent and return the important
- 2:03:08findings." Underneath this, the current
- 2:03:10Claude code tool is called agent. You
- 2:03:13usually don't need to call the internal
- 2:03:15tool yourself. You can just tell Claude
- 2:03:17what should be delegated and let it
- 2:03:19handle the mechanics. So, once the
- 2:03:21research comes back, don't immediately
- 2:03:23say, "Build an admin dashboard."
- 2:03:26First, decide what this first admin
- 2:03:29version actually needs.
- 2:03:31For our store, keep it focused. We need
- 2:03:34admin-only access,
- 2:03:36basic dashboard overview,
- 2:03:38product, category, and order management,
- 2:03:41as well as inventory updates.
- 2:03:43We don't need multiple admin permission
- 2:03:46levels,
- 2:03:47warehouse management, advanced
- 2:03:49analytics, staff invitations, refunds,
- 2:03:52or complicated fulfillment systems.
- 2:03:54At least not yet. Now, even without our
- 2:03:56admin panel, but just with the full
- 2:03:59logic of the databases, authentication,
- 2:04:01and more, our application has changed
- 2:04:03massively since we ran that first deep
- 2:04:06scan. Our application now holds
- 2:04:08authentication, sessions, customer data,
- 2:04:12payment logic, orders, and very soon an
- 2:04:15entire admin side with its own
- 2:04:17authorization. So, before we begin
- 2:04:20working on the admin platform of the
- 2:04:22application, we want to commit and push
- 2:04:24everything that we've done so far,
- 2:04:26because there's a lot of work that was
- 2:04:27done. So, I'll tell it, "Commit and push
- 2:04:30all the work done so far." And as soon
- 2:04:33as the changes are in, we can run the
- 2:04:35second Code Rabbit AI deep scan. Let's
- 2:04:39let it look across of it all to see just
- 2:04:41how well have you done your assessment
- 2:04:43or how well Claude has developed it.
- 2:04:46You can also connect Slack to be updated
- 2:04:48when the deep scan is done or you can
- 2:04:50just head over here where you can see
- 2:04:52them estimating and then running. The
- 2:04:54deep scan report will likely be
- 2:04:56different for you than what it is for
- 2:04:58me. But thankfully, the process of
- 2:05:00resolving some of these vulnerabilities
- 2:05:02is the same as what I've shown you
- 2:05:04before. So, feel free to take a coffee
- 2:05:06until the deep scan is back, resolve the
- 2:05:08vulnerabilities which you believe need
- 2:05:10fixing, and then let's continue.
- 2:05:13And here's the thing, from this point
- 2:05:15on, building the admin side is nothing
- 2:05:18you haven't done before. You'd take all
- 2:05:21of these sub agent findings into plan
- 2:05:23mode and plan the admin experience.
- 2:05:27You'd read that plan carefully,
- 2:05:29especially around one thing,
- 2:05:31authorization has to live on the server
- 2:05:34because hiding the admin link isn't
- 2:05:36authorization. And then a normal
- 2:05:38customer should never be able to open an
- 2:05:40admin URL or call an admin action
- 2:05:43directly. But that's exactly the kind of
- 2:05:45decision that you catch in the plan, not
- 2:05:48after the code is written.
- 2:05:50And then, you'd build it feature by
- 2:05:52feature. Admin access first, then
- 2:05:55product management, then inventory, and
- 2:05:57then orders.
- 2:05:59The same loop you've used throughout the
- 2:06:01rest of the course, describe the
- 2:06:03feature, plan when the decision is
- 2:06:05expensive, let Claude build, review, and
- 2:06:08verify. So, the admin side is part two
- 2:06:11of your assessment. Every prompt in
- 2:06:14order is going to be in the free
- 2:06:16resource down below in case you want to
- 2:06:17follow along, but go ahead and give it a
- 2:06:20shot. Try to build it yourself or take a
- 2:06:23look at a couple of hints in that
- 2:06:24document that I've shared. So, pause the
- 2:06:26video and go ahead and do it right now.
- 2:06:29And let me know in the comments how it
- 2:06:30went. Were you able to successfully add
- 2:06:32the admin side to this luxury and overly
- 2:06:36expensive e-commerce store?
- 2:06:39Hopefully, the answer is yes. But even
- 2:06:41if you've built it properly, check
- 2:06:44whether the Claude MD or agents in the
- 2:06:46file that you had from the beginning
- 2:06:48properly describes the application that
- 2:06:50you have right now,
- 2:06:51not the one from five lessons ago.
- 2:06:53Because if that is the case, every
- 2:06:56future Claude session will start with
- 2:06:58stale information that has no idea about
- 2:07:01the admin interface or some of the
- 2:07:03features you developed within it. So,
- 2:07:05update it either manually or through the
- 2:07:08conversation with Claude to analyze the
- 2:07:10code base and update the necessary parts
- 2:07:13and then review it. Or you can use a
- 2:07:15skill that I built specifically for that
- 2:07:17purpose.
- 2:07:18In this case, the skill is part of the
- 2:07:21agentic engineering workflow and it is
- 2:07:24the sync skill.
- 2:07:25You can check it out right here.
- 2:07:27Its goal is to run it after a specific
- 2:07:30feature or an application is complete to
- 2:07:33keep the durable knowledge current.
- 2:07:35Simply put, it keeps your project
- 2:07:37context in sync with the code base by
- 2:07:39checking your latest Git commits,
- 2:07:41updates the relevant parts of Claude and
- 2:07:44agents in the files, and flags anything
- 2:07:46that no longer matches how the project
- 2:07:48actually works.
- 2:07:50And you can use sync completely on your
- 2:07:51own. You don't need the entire workflow
- 2:07:54as it's free and open source. So, maybe
- 2:07:56this is the right chance to give it a
- 2:07:57shot if you haven't already. But now,
- 2:08:00just take a look at how your usage of
- 2:08:02Claude code grew as you kept using the
- 2:08:05app. You started this course with Claude
- 2:08:07in an empty folder. Then, you added the
- 2:08:10permissions so you controlled what it
- 2:08:11could do. You used plan mode when
- 2:08:14decisions became expensive.
- 2:08:16You also used a couple of skills, one of
- 2:08:18which you created yourself, as well as
- 2:08:21external skills and plugins when you
- 2:08:23needed them, when libraries themselves
- 2:08:25provided the guidance.
- 2:08:27And you also used sub agents. When the
- 2:08:30code base got big enough that
- 2:08:31investigation didn't belong in the main
- 2:08:34context.
- 2:08:35And that's the progression to remember.
- 2:08:38Don't start every project by enabling
- 2:08:40every Claude code feature you know.
- 2:08:43Instead, let the problem you have create
- 2:08:45the reason to use that feature. Is that
- 2:08:48everything you need to know about Claude
- 2:08:50code?
- 2:08:51Well, definitely not. You just learned
- 2:08:53how sub agents let Claude split the work
- 2:08:56into separate contexts so different
- 2:08:58parts of a problem can be investigated
- 2:09:00independently. But you can take that
- 2:09:02same idea much further. What if those
- 2:09:04agents don't just investigate different
- 2:09:07parts of the application? But what if
- 2:09:09they start building different features
- 2:09:11at the same time? Well, Claude code has
- 2:09:14a solution for that, too.
- 2:09:15You can combine agents with isolated Git
- 2:09:18work trees. So each agent can work on
- 2:09:21its own copy of the repository while
- 2:09:23building features in parallel. And
- 2:09:25that's where you start getting into the
- 2:09:26more advanced side of Claude code.
- 2:09:30Parallel feature development, Git work
- 2:09:33trees, MCP servers, and there's also
- 2:09:36hooks to automate your actions.
- 2:09:39Multi-agent workflows and complete
- 2:09:42production engineering workflows such as
- 2:09:44the one that I've built on top of Claude
- 2:09:46code for professional software
- 2:09:48engineering.
- 2:09:49But yeah, sub agents are really just the
- 2:09:51beginning of that idea.
- 2:09:53You learn how to separate the context,
- 2:09:56but the next step is learning how to
- 2:09:57separate the actual work happening
- 2:10:00across multiple agents at the same time.
- 2:10:04But that's a story for another day. Or
- 2:10:06another video at least. If you'd like to
- 2:10:08see an advanced version of the Claude
- 2:10:11code crash course,
- 2:10:12leave a like, share the video, and let
- 2:10:14me know down below in the comments. If
- 2:10:16you request it, I'll make it.
- 2:10:19With that in mind, let's go to the outro
- 2:10:21because I have something important to
- 2:10:23share with you.
- 2:10:26At this point, you've gone quite a bit
- 2:10:28further than simply opening Claude Code
- 2:10:31and asking it to build something. You've
- 2:10:33learned how to give Claude proper
- 2:10:35project context with Claude and agent
- 2:10:38CMD files.
- 2:10:39Control what it can do with permissions.
- 2:10:42Use plan mode when the approach matters.
- 2:10:45Turn repeatable processes into skills
- 2:10:48and delegate focused work to sub agents
- 2:10:51without filling your main context.
- 2:10:53And honestly, this is where Claude Code
- 2:10:56starts becoming much more interesting.
- 2:10:59Because once you understand those
- 2:11:01pieces, you can start building much
- 2:11:03larger workflows around them. For
- 2:11:05example, the next thing I would normally
- 2:11:08teach are using Git work trees, so
- 2:11:11agents can safely work on different
- 2:11:13features at the same time.
- 2:11:16Connecting Claude to external tools
- 2:11:18through MCPs. Using hooks when something
- 2:11:21should happen automatically every time.
- 2:11:24And combining everything into a complete
- 2:11:27engineering workflow where Claude can
- 2:11:29plan, build, verify, review, and even
- 2:11:32coordinate work across several agents.
- 2:11:36And that's where you stop using Claude
- 2:11:38Code like a really powerful coding
- 2:11:40assistant. And start treating it more
- 2:11:43like an actual engineering system around
- 2:11:46your application. So, here's what I'll
- 2:11:48do.
- 2:11:49If this crash course gets enough likes
- 2:11:51and comments, and you want a more
- 2:11:53detailed video,
- 2:11:55I'll continue from exactly where this
- 2:11:56lesson ends and cover the next layer in
- 2:11:59detail.
- 2:12:00Work trees, MCPs, hooks, multi-agent
- 2:12:03workflows. And if you already got that
- 2:12:05Claude Code cheat sheet, that means I
- 2:12:07have your email, so whenever I do put
- 2:12:09that video out, I'll let you know via
- 2:12:11email. But, if you don't want to wait,
- 2:12:14and if you want to immediately dive much
- 2:12:16deeper than that second video would go.
- 2:12:19The agentic engineering course that I
- 2:12:20showed you earlier already covers that
- 2:12:23entire layer.
- 2:12:24From parallel feature development and
- 2:12:26isolated work trees to hooks, automated
- 2:12:29verification, and the complete process
- 2:12:32that I use on larger applications and
- 2:12:35even existing codebases. As part of it,
- 2:12:37I'll also hold a live workshop that you
- 2:12:40can join and ask any questions you might
- 2:12:42have.
- 2:12:43So, I'll link it below. For now though,
- 2:12:46you already have everything you need to
- 2:12:48start building very differently with
- 2:12:50Claude Code. Don't try to use every
- 2:12:53feature just because you learned it.
- 2:12:55Start with the basics.
- 2:12:57Give Claude Code good context.
- 2:12:59Keep your tasks small.
- 2:13:01Review what it does.
- 2:13:03Turn repeated processes into skills. Use
- 2:13:06sub-agents when work can happen
- 2:13:08separately. And slowly give Claude more
- 2:13:10freedom as you understand how it behaves
- 2:13:13on your own projects. That's the
- 2:13:15foundation.
- 2:13:16And everything after this is scaling
- 2:13:18that approach to a larger applications
- 2:13:21and more serious engineering work.
- 2:13:24And when you're ready for that,
- 2:13:26you know where to find it.
- 2:13:27Now, go build something.
- 2:13:30I'll see you in the next one.
About this transcript
This page contains the full transcript of Claude Code Full Course 2026 | How Senior Engineers Actually Build with AI by JavaScript Mastery, generated from the public captions YouTube serves with the video. The transcript has 21,040 words across 3,398 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 choose a caption track available on the video.
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, caption language selection, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.