YouTube2Text

Claude Code Full Course 2026 | How Senior Engineers Actually Build with AI — Transcript

by JavaScript Mastery · 21,040 words · 3,398 segments · language en · Watch on YouTube

Full transcript

  1. 0:00This is Claude code refusing to read my
  2. 0:03environment file because I told it that
  3. 0:06it's never allowed to. This is it laying
  4. 0:09out its entire database plan and waiting
  5. 0:12for my approval before it writes a
  6. 0:15single line of code. And this is it
  7. 0:18splitting one big investigation across
  8. 0:21five parallel agents because I asked it
  9. 0:24to. If your entire Claude code
  10. 0:26experience so far is typing something
  11. 0:28like build this feature and then hitting
  12. 0:30enter, you're using maybe 10% of what
  13. 0:34this tool allows you to do. So,
  14. 0:36let me ask you this. Do you really know
  15. 0:40when to use skills, sub agents, project
  16. 0:43rules, plan mode, permissions, and all
  17. 0:46the other parts of Claude code that
  18. 0:48decide how your agent actually works?
  19. 0:52Because if your answer to some of these
  20. 0:54is no,
  21. 0:55then yes, there is still quite a lot to
  22. 0:58learn. And companies are already paying
  23. 1:01engineers $200,000
  24. 1:04a year to build AI agents, orchestration
  25. 1:08systems, and production workflows. Not
  26. 1:10because these engineers can type build
  27. 1:13this feature into a prompt any better
  28. 1:14than you can, because knowing how to
  29. 1:17work with an agent while building a real
  30. 1:20software is a completely different skill
  31. 1:23from just getting one to generate code.
  32. 1:25And that's the skill this video is
  33. 1:27about.
  34. 1:28Hi there and welcome to this Claude code
  35. 1:31crash course where I'm going to spend
  36. 1:33the next few hours showing you random
  37. 1:35commands one after another and expecting
  38. 1:38you to remember all of them.
  39. 1:40Oh, wait.
  40. 1:42Wrong script. Instead, you're going to
  41. 1:44learn Claude code by actually using it
  42. 1:47on a real app. Throughout this course,
  43. 1:49we'll work on an e-commerce app inspired
  44. 1:52by a real luxury storefront. But here's
  45. 1:55the important part. Every feature we
  46. 1:57build exists for one reason.
  47. 2:00It's the moment a Claude Code concept
  48. 2:03actually becomes useful. A design system
  49. 2:07when you learn how permissions work. A
  50. 2:09real Postgres database when you learn
  51. 2:11why the plan mode exists. Reusable
  52. 2:14workflows when you notice the same
  53. 2:16process repeating.
  54. 2:18Separate agents when the code base gets
  55. 2:20big enough that one context can't carry
  56. 2:23everything. And if you've been on this
  57. 2:25channel a while, you know I love a long
  58. 2:28build. This isn't that. This video is
  59. 2:32optimized for one thing. That you walk
  60. 2:35away actually understanding how to work
  61. 2:38with an AI coding agent in a couple of
  62. 2:40hours and not a couple of weekends.
  63. 2:43So, along the way, you'll learn how
  64. 2:46Claude works inside your code base. How
  65. 2:48to give it persistent project context
  66. 2:50with Claude and agent.md file. How
  67. 2:53permissions control what it can access.
  68. 2:56When plan mode is actually worth it.
  69. 2:59How skills turn processes you keep
  70. 3:01repeating into reusable workflows.
  71. 3:04And how sub agents let Claude hand over
  72. 3:08focused work to another agent without
  73. 3:11filling your main context with
  74. 3:13everything else it had to read along the
  75. 3:15way. The goal isn't that you know 50
  76. 3:18Claude Code commands by the end.
  77. 3:20The goal is that you understand how to
  78. 3:22work with a coding agent and know
  79. 3:24exactly when and why to reach for any of
  80. 3:27these. Because pretty soon, simply
  81. 3:30saying I use AI to code isn't going to
  82. 3:34mean very much.
  83. 3:35Almost everyone will. What will matter
  84. 3:38is how well you work with it. And to
  85. 3:41make it even easier, you don't need to
  86. 3:43memorize anything in this video.
  87. 3:45I've created a completely free Claude
  88. 3:47Code cheat sheet with the commands
  89. 3:49you'll actually to coming back to, such
  90. 3:51as sessions, context management,
  91. 3:53permissions, models, plan mode, skills.
  92. 3:56All of it is there.
  93. 3:57So, you can just grab it from the link
  94. 3:59in the description and keep it open
  95. 4:00beside you instead of trying to remember
  96. 4:03everything. Oh, and one more thing
  97. 4:05before we start. Everything in this
  98. 4:06crash course scales up into a complete
  99. 4:09engineering workflow that I've built and
  100. 4:12open-sourced for free. And there's a
  101. 4:13full agentic engineering course if you
  102. 4:16ever want to go deeper. We've been
  103. 4:17testing it with a close group of
  104. 4:19engineers who went through the full
  105. 4:20course and loved it.
  106. 4:22And as of today, it is officially
  107. 4:24public.
  108. 4:25I'll leave the link down in the
  109. 4:26description. And with it, you'll also
  110. 4:28get a discount on top of the current
  111. 4:30offer.
  112. 4:31Preparing for that course for the past 2
  113. 4:33years built the foundation that I'm
  114. 4:36going to use right now to teach you the
  115. 4:37Claude code skills in this video. So,
  116. 4:40for now, we'll proceed with that, but if
  117. 4:42at any point in time you want to go
  118. 4:43deeper,
  119. 4:44you know where to find it. But, that's
  120. 4:46all I'll say about it for now. So, let's
  121. 4:48get into Claude code.
  122. 5:00So, what is Claude code?
  123. 5:03You can already open Claude, ask it
  124. 5:05coding questions, give it files, and
  125. 5:08build things with it.
  126. 5:09So, you might be thinking,
  127. 5:11"Why do you need Claude code?"
  128. 5:14Well, Claude code can work directly
  129. 5:16inside your development environment.
  130. 5:18You open your project, run Claude code,
  131. 5:22and it can read files, search through
  132. 5:24your code base, edit code, run terminal
  133. 5:27commands, use Git, run tests, and check
  134. 5:30whether its own changes actually worked.
  135. 5:33Imagine you're building the e-commerce
  136. 5:35app in this course, and customers can
  137. 5:37add more units to their cart than you
  138. 5:40actually have in stock. Instead of
  139. 5:42finding the cart logic yourself, copying
  140. 5:46it into Claude and explaining everything
  141. 5:48around it, you could simply say,
  142. 5:50"Customers can add more units to their
  143. 5:52cart than what we have in stock."
  144. 5:55Find out why and fix it.
  145. 5:58Claude can then search for the cart
  146. 6:00logic, inspect both your product and
  147. 6:03inventory code, follow the flow, make
  148. 6:05the necessary change, and then run the
  149. 6:08tests. That's what makes Claude Code an
  150. 6:11agentic coding tool.
  151. 6:13The Claude model is still doing the
  152. 6:16reasoning underneath,
  153. 6:17but Claude Code gives that model the
  154. 6:20tools, project context, and environment
  155. 6:23it needs to actually work on your code.
  156. 6:27That's the important difference. So,
  157. 6:29wait, does it mean that Claude can see
  158. 6:32my private code?
  159. 6:34Yes, Claude Code can read files inside
  160. 6:37your project you've given it access to.
  161. 6:40It searches your project locally rather
  162. 6:42than first uploading and then indexing
  163. 6:45the entire repository somewhere else.
  164. 6:48But, when Claude needs the contents of a
  165. 6:50file to reason about your task, relevant
  166. 6:53information can still be sent to the
  167. 6:55Claude model. So, Claude Code runs
  168. 6:58locally does not mean that everything
  169. 7:01always stays in my machine. If you're
  170. 7:03working with private company code,
  171. 7:06understand the data policy of the
  172. 7:07account you're using, and follow
  173. 7:09whatever rules your company has around
  174. 7:11AI tools. And then, there's the obvious
  175. 7:14next question. What about the .env?
  176. 7:17Later on in this course, our e-commerce
  177. 7:19app will contain a .env files with
  178. 7:22things like a database URL, a better
  179. 7:25auth secret, or even a Stripe secret
  180. 7:28key. You shouldn't assume that Claude
  181. 7:30automatically knows those values are
  182. 7:32sensitive and should never touch them.
  183. 7:35Claude Code has a permission system
  184. 7:37where you can explicitly control what it
  185. 7:40can read, edit, or execute.
  186. 7:43You can block files such as the .env or
  187. 7:47.env.anything,
  188. 7:49secrets, or any kind of credentials, and
  189. 7:52therefore control which tools Claude is
  190. 7:55allowed to use. I'll show you how you
  191. 7:57can set this up properly later in the
  192. 7:59course. And we'll actually test it by
  193. 8:02blocking an environment file, asking
  194. 8:04Claude to read it, and checking whether
  195. 8:06that access is refused. For now, just
  196. 8:10remember that sensitive files should be
  197. 8:12explicitly protected. Okay. Now, let's
  198. 8:16talk about how Claude code actually
  199. 8:18works.
  200. 8:20Now that Claude can work directly inside
  201. 8:23your project, how does it decide what to
  202. 8:26do? Most tasks follow a simple loop.
  203. 8:29Gather context, take action, and then
  204. 8:32verify the result.
  205. 8:34So, imagine one of your inventory tests
  206. 8:36starts failing.
  207. 8:38You ask, "Find out why the inventory
  208. 8:40test is failing and fix it."
  209. 8:43Claude might first run the test,
  210. 8:46then read the error, then search for the
  211. 8:48inventory logic, then inspect the
  212. 8:50relevant files, then make a change, and
  213. 8:53then run the test again. And if it still
  214. 8:55fails, Claude gets new information from
  215. 8:58that result and continues. That's the
  216. 9:01basic example of an agentic loop.
  217. 9:04And while this is happening, you'll
  218. 9:06actually see the tools that Claude is
  219. 9:08using. Read when it opens a file,
  220. 9:11glob when it's looking for files
  221. 9:14matching a pattern,
  222. 9:15grep when it's searching through the
  223. 9:17file contents,
  224. 9:18edit when it's changing an existing
  225. 9:20file, write when it's creating a file,
  226. 9:24and bash when it's running something in
  227. 9:26your terminal, such as pnpm build, test,
  228. 9:29or git status.
  229. 9:30And if Claude needs information from
  230. 9:33outside your project, you may see web
  231. 9:35search and web fetch.
  232. 9:38Later, for example, Claude might use the
  233. 9:41web to check the current drizzle
  234. 9:42documentation or research a design
  235. 9:44reference for the storefront. So, don't
  236. 9:47only read Claude's final answer.
  237. 9:50Watch what it's doing. If you see it
  238. 9:52reading your product schema while
  239. 9:54debugging stock, you know what it's
  240. 9:56investigating.
  241. 9:58And if you see tests running through
  242. 9:59bash, you know it's verifying its work.
  243. 10:02And if you see web search,
  244. 10:04it looks like Claude decided it needed
  245. 10:05information from outside the project,
  246. 10:08maybe from Stack Overflow, who knows.
  247. 10:10And you can totally interrupt Claude
  248. 10:12while it's working. If it makes a wrong
  249. 10:15assumption or starts heading somewhere
  250. 10:17else you don't want, correct it instead
  251. 10:19of waiting for the entire task to
  252. 10:20finish. You can do that by simply
  253. 10:22pressing the escape key. Now, what can
  254. 10:25Claude code do by default?
  255. 10:27Before you add any skills, MCP servers,
  256. 10:30sub agents, or anything more advanced,
  257. 10:33Claude code can already do you a lot.
  258. 10:36It can read, create, and edit files,
  259. 10:39search through your code base, run shell
  260. 10:41commands, start servers, run tests, work
  261. 10:44with Git, search the web, fetch
  262. 10:46documentation, and use the supported
  263. 10:48code intelligence, such as errors,
  264. 10:51definitions, and references. That's
  265. 10:53already enough to build a large part of
  266. 10:56the e-commerce app in this course.
  267. 10:58And you'll learn each of these in more
  268. 11:00detail as they start helping you build
  269. 11:02faster. So,
  270. 11:04let's install it. Claude code is
  271. 11:06available in several places, including
  272. 11:08the terminals, IDEs, desktop, and the
  273. 11:11web. For this course, I'll start mostly
  274. 11:14from the terminal because it makes it
  275. 11:16very easy to see what Claude is actually
  276. 11:18doing. So, head over to Claude code
  277. 11:21website and follow the instructions for
  278. 11:23your operating system. Once you install
  279. 11:25it, you can verify it by running Claude
  280. 11:28{dash} {dash} version.
  281. 11:30And if you'd rather work inside an
  282. 11:32editor, Claude Code is also available
  283. 11:34through supported IDE integrations such
  284. 11:37as VS Code, and you can use it through
  285. 11:39compatible editors like Cursor as well.
  286. 11:42Once we check it out in the terminal, I
  287. 11:44would highly recommend that you also
  288. 11:45download Claude Code as a VS Code
  289. 11:48extension and then check it out there.
  290. 11:50It has a bit of a friendlier UI. And as
  291. 11:53I said, there are also web, desktop, and
  292. 11:56even remote ways to use Claude Code such
  293. 11:58as from your phone. But you don't need
  294. 12:00to learn every option right now.
  295. 12:02Either way, the core workflow is the
  296. 12:05same and we'll use other surfaces later
  297. 12:07on when they actually become useful.
  298. 12:10Another important question is how do you
  299. 12:12access Claude Code? Well, the exact
  300. 12:15plans and usage limits can change over
  301. 12:18time, so understand what they offer and
  302. 12:20see what's enough for you.
  303. 12:22You can use Claude Code through
  304. 12:24supported Claude subscription plans.
  305. 12:26There's even team or organization plans
  306. 12:29or through API-based billing through the
  307. 12:31Claude console.
  308. 12:33If you're learning and building normal
  309. 12:35projects, a subscription will give you
  310. 12:37predictable usage, so definitely start
  311. 12:39there. And if you're using Claude Code
  312. 12:41heavily every day on bigger projects or
  313. 12:44longer sessions, you'll naturally need a
  314. 12:46higher tier.
  315. 12:48And API billing charges per token
  316. 12:51instead of a subscription allowance.
  317. 12:53That's usually the right choice for
  318. 12:55automation and CI pipelines, not for
  319. 12:57following a course because heavy
  320. 12:59interactive sessions add up quickly when
  321. 13:02you're paying per token. And that's
  322. 13:04really all you need to know for this
  323. 13:05course. Check out Anthropic's current
  324. 13:07pricing page whenever you're choosing a
  325. 13:09plan because details can change.
  326. 13:12So now, let's actually use Claude Code.
  327. 13:15Create an empty folder on your desktop,
  328. 13:17MKDIR,
  329. 13:19and call it Atelier Store. We're going
  330. 13:22to build an e-commerce store for a
  331. 13:24luxury brand like Gucci, for example.
  332. 13:27So, create it and then see the over into
  333. 13:30it. Once you do, we can actually open
  334. 13:32that folder up within VS Code. And we're
  335. 13:35in. Then, we can start Claude Code.
  336. 13:39I will open up my terminal and expand
  337. 13:41it, and then within it, simply run
  338. 13:44Claude.
  339. 13:45The first time you use it, you'll be
  340. 13:47asked to sign in.
  341. 13:49So, sign in. And then, you'll be asked
  342. 13:51whether you trust this folder.
  343. 13:54I'll say yes, we trust it.
  344. 13:56And then, you're in.
  345. 13:58When you take a first look at it, it
  346. 14:00seems like there's a lot of stuff
  347. 14:01happening right here.
  348. 14:03If this looks daunting,
  349. 14:05I would highly recommend hitting over to
  350. 14:07extensions
  351. 14:08and then search for Claude Code.
  352. 14:11I can even update it right here. It's a
  353. 14:13super popular Visual Studio Code
  354. 14:15extension
  355. 14:17that you can open up by simply pressing
  356. 14:19command shift P
  357. 14:20and searching for Claude Code.
  358. 14:23It'll open up that same session that we
  359. 14:25saw right here as part of our UI. And as
  360. 14:29you can see, we need to be logged in, so
  361. 14:31we can log in either through our
  362. 14:32subscription or through the Entropic
  363. 14:34console.
  364. 14:36In this case, most likely, you have an
  365. 14:38active subscription, so let's go with
  366. 14:40that. It'll open up a new browser
  367. 14:41window, so simply continue with
  368. 14:43whichever provider you chose.
  369. 14:45And then, you're in.
  370. 14:47As you can see here, you can see the
  371. 14:49model you're using.
  372. 14:51You can see the permissions and modes,
  373. 14:53such as whether you're in auto, plan,
  374. 14:55edit automatically, and so on. And you
  375. 14:57can also upload some files or run some
  376. 15:00additional commands.
  377. 15:02Anything that you can do within
  378. 15:03terminal, you can also do right here
  379. 15:05using the Claude Code VS Code extension.
  380. 15:08So, from this point onward, whether
  381. 15:10you're following along through a
  382. 15:11terminal or through the extension,
  383. 15:13either way works. I might even switch
  384. 15:16between the two.
  385. 15:17Now, here it says not logged in, but we
  386. 15:20just logged in through our extension, so
  387. 15:22if I just rerun Claude, it should be
  388. 15:24able to get access to our account. And
  389. 15:27we're in.
  390. 15:28Here, you can see which model we're
  391. 15:30using, and which effort is currently
  392. 15:32selected. Here, you can see some tips on
  393. 15:35how we can switch the model anytime by
  394. 15:37running the model command, and then
  395. 15:39switching between different models. At
  396. 15:41the bottom, you can also see which model
  397. 15:42you're using, how much of the context
  398. 15:44you have spent, and on which mode you're
  399. 15:46on. You can hold the shift tab to cycle
  400. 15:48between different modes. But yeah, let's
  401. 15:50give Claude the first real task.
  402. 15:54Let's tell it to set up a new Next.js
  403. 15:58e-commerce app in this folder using
  404. 16:02TypeScript,
  405. 16:04Tailwind,
  406. 16:05Better Auth,
  407. 16:07Drizzle ORM, and Postgres via Neon. I'll
  408. 16:11hold the shift key to be able to enter a
  409. 16:13couple of empty spaces, and tell it to
  410. 16:16only create the initial project
  411. 16:19structure, dependencies,
  412. 16:22configuration, .env example, and minimal
  413. 16:26integrations.
  414. 16:28I'll tell it very clearly, do not build
  415. 16:32e-commerce features, full auth flows,
  416. 16:36schemas, UI, payments, or deployment.
  417. 16:40That's going to come in later.
  418. 16:43So yeah, this is going to be our first
  419. 16:45prompt.
  420. 16:46So, just press enter and watch what
  421. 16:50Claude does. You'll probably see a lot
  422. 16:52of different commands like bash, write,
  423. 16:55read, and edit as it creates the
  424. 16:57project, installs packages, and checks
  425. 17:00its work. This is the agentic loop that
  426. 17:03you just learned about happening on the
  427. 17:06actual app you're going to be building
  428. 17:08throughout this course. If you want to,
  429. 17:10you can also expand specific pieces, and
  430. 17:13you can see that here it used the bash
  431. 17:14command to run something. Then, it's
  432. 17:17installing off and DB dependencies. So,
  433. 17:20let's give it some time until it
  434. 17:22finishes running this command. And in
  435. 17:24less than 2 and 1/2 minutes, it is done.
  436. 17:28It's scaffolded the project, verified
  437. 17:30it, and gave us info on the text stack
  438. 17:32it used, as well as the files it
  439. 17:34created.
  440. 17:35So, what you just saw right here was
  441. 17:38running Claude code interactively. You
  442. 17:41can stop the current session by pressing
  443. 17:43control C two times.
  444. 17:45And if you run Claude, like we just ran
  445. 17:48it right now, opens a new session that
  446. 17:50stays active.
  447. 17:52You give Claude a task, it works, you
  448. 17:55respond, and the conversation continues.
  449. 17:58But, you can also start Claude with the
  450. 18:00first task already included.
  451. 18:02You can do something like this.
  452. 18:04Claude, explain how this project is
  453. 18:07structured. That'll start the session,
  454. 18:10and then automatically prompt the agent
  455. 18:12to give you the answer.
  456. 18:13And there you go. The answer is in. But,
  457. 18:16in this way, the session will remain
  458. 18:18active. So, you can continue speaking
  459. 18:21with the agent. But, if you just want to
  460. 18:23ask it something, and then call it a
  461. 18:25day,
  462. 18:26there's also a one-off mode,
  463. 18:30where Claude performs a task, prints the
  464. 18:33results, and then exits. You can use it
  465. 18:35that way by adding the P tag, and then
  466. 18:38asking it a specific question. If you do
  467. 18:41that,
  468. 18:43Claude will perform the task, print out
  469. 18:45the result, and then exit.
  470. 18:48There you go.
  471. 18:49Back in the terminal. But, you can even
  472. 18:51pipe something into it,
  473. 18:53like this.
  474. 18:55Tail N 200 app logs, Claude P find
  475. 19:00anything unusual in these logs. So, if
  476. 19:02there were some logs, it will be able to
  477. 19:05go through it and share its output
  478. 19:07directly into the terminal. This becomes
  479. 19:09very useful later on for automation and
  480. 19:12CI.
  481. 19:14For now, just remember that Claude keeps
  482. 19:17the session open and Claude {dash} P
  483. 19:20runs one task and then exits. Then, the
  484. 19:23next major question is which model
  485. 19:26should you be using?
  486. 19:28So, if you're within the Claude window
  487. 19:30and you type {forward slash} model, you
  488. 19:33can see which models are currently
  489. 19:35available.
  490. 19:36The exact model names will change over
  491. 19:38time, so don't memorize the list from
  492. 19:41this video. Instead, think about them in
  493. 19:44terms of the task. Use a faster,
  494. 19:46general-purpose model for normal
  495. 19:48development, small fixes, and everyday
  496. 19:51coding. Use a stronger reasoning model
  497. 19:54when you're dealing with things like
  498. 19:55architecture, difficult debugging,
  499. 19:58larger refactors, or several systems
  500. 20:01integrating at once.
  501. 20:02For example, changing the layout of a
  502. 20:04product card probably doesn't need your
  503. 20:07strongest model. Figuring out how the
  504. 20:09inventory should behave across the
  505. 20:11database, storefront, and checkout,
  506. 20:13well, that might need a stronger one.
  507. 20:16So, yeah, whenever you want to switch
  508. 20:18the model, you can simply use the
  509. 20:19{forward slash} model command. But,
  510. 20:22yeah, that's enough for now. You'll
  511. 20:24understand the model choices much better
  512. 20:26once you actually start working on the
  513. 20:28harder parts of our e-commerce app. And
  514. 20:31other than that, you don't need to know
  515. 20:3350 other commands. I will show you some
  516. 20:36of the more important ones, but don't
  517. 20:38try to remember all of them.
  518. 20:40That's exactly why I included that free
  519. 20:42cheat sheet in the description down
  520. 20:44below, so you can open it up, have it
  521. 20:46side by side. Whenever you need
  522. 20:48something, you know where it is. And
  523. 20:50with time, you'll naturally remember it.
  524. 20:52So, you can start Claude like this.
  525. 20:56You can start Claude with a task, as you
  526. 20:58know. You can run one task and then exit
  527. 21:02by using the {dash} P command.
  528. 21:05You can also continue from your most
  529. 21:08recent session by running Claude-c.
  530. 21:12You can also resume an older session by
  531. 21:15running Claude-r, and then you can
  532. 21:17select which session you want to run.
  533. 21:19You can see which other commands are
  534. 21:21available by running Claude, and then
  535. 21:23within it, you can run help. Here, you
  536. 21:25can see all the information. And one
  537. 21:28more, which is super important, is
  538. 21:31forward-slash clear. But, the question
  539. 21:33is, when should you use clear to start a
  540. 21:36new session with an empty context? Well,
  541. 21:39suppose that later on, you spend half an
  542. 21:41hour debugging some authentication
  543. 21:44connection.
  544. 21:45Claude has read your auth code, seen
  545. 21:48several errors, and tried a few
  546. 21:50different approaches. Then, you suddenly
  547. 21:52say, "Redesign the product cards."
  548. 21:55Claude is still carrying all that
  549. 21:57authentication conversation in the
  550. 21:58current session. So, that information
  551. 22:01probably isn't helping with the product
  552. 22:03card task. That's when running clear is
  553. 22:06useful,
  554. 22:07as it gives you a fresh conversation.
  555. 22:10You don't need to use it after every
  556. 22:11task. Use it when you're moving onto
  557. 22:14something genuinely unrelated.
  558. 22:17You'll learn more about context
  559. 22:18compaction and sub-agents later on.
  560. 22:22Or, if you want to dive deeper, you can
  561. 22:23check out the Agentic Engineering
  562. 22:25course. I believe that under the third
  563. 22:27module, I'm covering a lot of stuff
  564. 22:30regarding your agents, like what the
  565. 22:32agent sees, how they read your code
  566. 22:34base, context windows, context rod,
  567. 22:37topic switching, clearing versus
  568. 22:38compacting, and much more.
  569. 22:41But, yeah. Now that the initial setup is
  570. 22:43finished, you can simply ask the agent
  571. 22:45to explain the code base,
  572. 22:48such as the architecture, technologies,
  573. 22:50the main folders, and important parts
  574. 22:52currently connect. Now, if you watch
  575. 22:54Claude again, you'll probably see it use
  576. 22:57bash, glob, or grep, as it searches
  577. 23:00through the project and builds an
  578. 23:02The point isn't only to read the final
  579. 23:04explanation.
  580. 23:06Pay attention to how Claude finds the
  581. 23:09answer. That's one of the most useful
  582. 23:11habits you can build while learning
  583. 23:13Claude code. You should understand what
  584. 23:15Claude code is doing even when Claude is
  585. 23:17doing most of the actual file and
  586. 23:20command work for you. But with this,
  587. 23:22another problem appears immediately.
  588. 23:25As the app grows, you don't want to keep
  589. 23:27telling Claude some specific rules, like
  590. 23:30use pnpm or we're using Drizzle.
  591. 23:35Or this is how tests should run. Or to
  592. 23:39keep the design consistent, Claude needs
  593. 23:42a way to know those project instructions
  594. 23:45every time you start a new session.
  595. 23:47And that's exactly where the claude.md
  596. 23:52or as of super recently agents.md, which
  597. 23:56now Claude code is reading as well,
  598. 23:58comes in. So, let's cover those in the
  599. 24:00next lesson.
  600. 24:03Now that you've got your store project
  601. 24:05running, what happens when you close
  602. 24:08Claude code and then come back tomorrow?
  603. 24:11Claude won't automatically remember that
  604. 24:14you're using pnpm, how you're using
  605. 24:16Drizzle or RAM to define your Postgres
  606. 24:18schemas, or that same mistake that you
  607. 24:21already corrected twice.
  608. 24:23You don't want to keep explaining the
  609. 24:25same project every time you start a new
  610. 24:28session.
  611. 24:29And that's exactly where the claude.md
  612. 24:32or the agents.md file comes in.
  613. 24:34Claude.md is simply a markdown file
  614. 24:37where you give Claude instructions about
  615. 24:39your project.
  616. 24:41Claude loads it automatically when a
  617. 24:43session starts, so those instructions
  618. 24:45are already there before you even give
  619. 24:47it your first task. For example, use
  620. 24:50pnpm instead of npm. Use Drizzle for
  621. 24:54database access. Or run pnpm type check
  622. 24:57before finishing larger changes.
  623. 25:00Instead of repeating those things again
  624. 25:02and again, you put them in a Claude MD.
  625. 25:05Then, whenever Claude works on this
  626. 25:07project, it already knows them.
  627. 25:09And as of recently, it is official.
  628. 25:13Claude is finally adding support for
  629. 25:15agents MD to Claude code. Starting today
  630. 25:18in the newest version, if there is no
  631. 25:21Claude MD in a folder, Claude will check
  632. 25:24for and use the agents MD file. So,
  633. 25:27whenever I mention anything about the
  634. 25:29Claude MD, the same rules go for the
  635. 25:32agents MD file. This agents MD file has
  636. 25:35been the standard for all other coding
  637. 25:37tools, and it looks like Claude code is
  638. 25:39catching up, too. But, there's one thing
  639. 25:42you need to understand. Claude MD gives
  640. 25:44Claude instructions. It doesn't
  641. 25:47technically block Claude from doing
  642. 25:49something.
  643. 25:50So, if you write never modify migration
  644. 25:53files manually,
  645. 25:54Claude should follow that rule. But, it
  646. 25:57still technically has access to those
  647. 26:00files. If something absolutely shouldn't
  648. 26:02happen, that's where permissions,
  649. 26:05sandboxing, and hooks come in. And we'll
  650. 26:08get to those next.
  651. 26:10But, before going further, you should
  652. 26:12understand the context window.
  653. 26:15This is basically the information Claude
  654. 26:18is working with during the current
  655. 26:20session.
  656. 26:21That includes your conversation, files
  657. 26:24that Claude has read, terminal output,
  658. 26:27tool results, Claude MD file, and all
  659. 26:30the other memory Claude has loaded.
  660. 26:33And that context has a limit.
  661. 26:35So, if you keep loading unnecessary
  662. 26:38information into it, you're using space
  663. 26:40and attention that Claude could be using
  664. 26:43on the actual task. And that's also why
  665. 26:46Claude MD shouldn't become some massive
  666. 26:49document. As more information enters the
  667. 26:53context window, Claude has more things
  668. 26:55competing for its attention.
  669. 26:57You can think of it like an attention
  670. 26:59budget.
  671. 27:00Every line inside the Claude or Agent MD
  672. 27:03files is using some of that budget
  673. 27:06because Claude keeps loading that file
  674. 27:08while working on your project. So, don't
  675. 27:10put something there just because Claude
  676. 27:12might need to use it one day. Put things
  677. 27:14there because Claude should know them
  678. 27:16whenever it works on the project. And
  679. 27:19you'll often see the guidance around
  680. 27:20keeping Claude MD well under 200 lines,
  681. 27:23but don't treat 200 lines as a target.
  682. 27:26If everything useful fits into 30 or 40
  683. 27:29lines, that's even better. And talking
  684. 27:32about the context budget, in one of the
  685. 27:34lessons in the course, I go over
  686. 27:36something that even I didn't know before
  687. 27:38I started working on it. And that's
  688. 27:40context rot.
  689. 27:42I mean, I knew about the concept of
  690. 27:44context rot. You shouldn't fill up your
  691. 27:46context window because agent's
  692. 27:48performance drops significantly, but I
  693. 27:50didn't know it was this severe.
  694. 27:53Don't wait until the window is nearly
  695. 27:56full because a model advertising 200,000
  696. 27:59token window can show real, measurable
  697. 28:02degradation starting at 50,000 tokens,
  698. 28:06which is only a quarter in.
  699. 28:08So, the number on the box is the
  700. 28:10technical ceiling, but it is not the
  701. 28:12point where the quality starts to slip.
  702. 28:16So, as a rule of thumb, context rot
  703. 28:18isn't something that happens near the
  704. 28:19edge of a full window. It starts well
  705. 28:22before that, continuously, not as a
  706. 28:24cliff. So, whenever you start working on
  707. 28:26something new, clear the context. Now,
  708. 28:29let's talk about where does the Claude
  709. 28:31MD or Agent MD file lives because there
  710. 28:35isn't only one place you can have it.
  711. 28:37Claude supports different levels of
  712. 28:39instructions. You can have personal
  713. 28:41instructions under the dot Claude folder
  714. 28:44and then Claude MD file, which applies
  715. 28:46across all your projects.
  716. 28:49So, if there's something you personally
  717. 28:51want Claude to follow everywhere, you
  718. 28:53can put it there.
  719. 28:54Then, there are project instructions.
  720. 28:58Inside your project in the root of the
  721. 28:59application, you can just put the Claude
  722. 29:01or agent MD file there.
  723. 29:04This is usually the one you'll use the
  724. 29:05most. For our luxury store application,
  725. 29:08this is where you can keep things like
  726. 29:10your stack, commands, database rules,
  727. 29:13testing rules, and storefront design
  728. 29:16rules. And you can also commit this file
  729. 29:18to get, so everyone working on the
  730. 29:20project gives Claude the same project
  731. 29:23instructions. This is something you
  732. 29:24might not have known about, but there
  733. 29:26are also local project instructions. You
  734. 29:29can also have something like a
  735. 29:30.claud.local.md,
  736. 29:33which is a file that only applies to you
  737. 29:36on this specific project. Maybe you use
  738. 29:38a local test account. Maybe you have
  739. 29:41your own sandbox URL. Things like that
  740. 29:44can live here and normally stay out of
  741. 29:46Git. And Claude can then use
  742. 29:48instructions from all of these levels
  743. 29:50together. And if you're working on a
  744. 29:52much larger code base or a monorepo,
  745. 29:55this can go quite a bit further.
  746. 29:57You can have multiple nested Claude MD
  747. 30:00files across different parts of the
  748. 30:02project. So, Claude only pulls the
  749. 30:04instructions that are relevant to that
  750. 30:06area it's actually working on. I don't
  751. 30:08want to go too deep into that here
  752. 30:10because this is a crash course, but this
  753. 30:12is exactly the kind of concept that I
  754. 30:14cover inside of the Agentic Engineering
  755. 30:16course. And because that course uses
  756. 30:19that completely free open-source Agentic
  757. 30:21Engineering workflow, you get a set of
  758. 30:24those reusable skills and commands that
  759. 30:26inspect your code base and help you set
  760. 30:29up the right project context
  761. 30:30automatically.
  762. 30:32What does that mean? Well, if your
  763. 30:34project is small, it may create only one
  764. 30:36Claude MD file.
  765. 30:38But, if the code base is much larger, it
  766. 30:40can create multiple nested Claude MD
  767. 30:43files, so each one is loaded only when
  768. 30:46Claude starts working on that specific
  769. 30:48part of the project.
  770. 30:50The workflow, of course, goes beyond
  771. 30:52context files, too, as it's built around
  772. 30:54helping you develop applications with
  773. 30:56stronger engineering and system design
  774. 30:58practices instead of just throwing
  775. 31:00prompts at an agent randomly. And yeah,
  776. 31:02you can use the workflow completely on
  777. 31:04your own since it's free and
  778. 31:05open-source, but if you want to learn
  779. 31:07how to use it properly alongside more
  780. 31:09advanced Claude concepts and the real
  781. 31:11agentic engineering course workflows,
  782. 31:14well, then check out the agentic
  783. 31:15engineering course. But for our Gucci
  784. 31:18store application, just having one
  785. 31:20project-level Claude MD file is more
  786. 31:23than enough for now. And you might also
  787. 31:25think, "But wait, doesn't Claude already
  788. 31:28have memory?"
  789. 31:29Well, it does. Claude code also has
  790. 31:32auto-memory, but the difference is
  791. 31:35simple. Claude MD is what you
  792. 31:37intentionally tell Claude.
  793. 31:40Auto-memory is what Claude learns while
  794. 31:42working with you. For example, while
  795. 31:44working on our Gucci store, Claude
  796. 31:47discovers some weird issue with your
  797. 31:49local setup. Or maybe you correct the
  798. 31:51same project-specific behavior a couple
  799. 31:53of times.
  800. 31:54Claude can save useful things like that,
  801. 31:57so they can be used again in future
  802. 31:59sessions. Each project gets its own
  803. 32:01memory folder with a memory.md as the
  804. 32:04main file.
  805. 32:05Claude can also create other memory
  806. 32:07files for more specific things. To see
  807. 32:10what is stored, you can just run
  808. 32:13and you can see that the auto-memory has
  809. 32:15been turned on with the project
  810. 32:17instructions checked in at the Claude MD
  811. 32:19file.
  812. 32:20There are some additional instructions
  813. 32:22and user instructions.
  814. 32:25And you can also open up the auto-memory
  815. 32:27folder. And then to see what Claude has
  816. 32:29stored within your current session, you
  817. 32:31can just run context.
  818. 32:34This will show you how much of the
  819. 32:35context has currently been spent and
  820. 32:37show you the estimated usage by the
  821. 32:40category. So, the main question is
  822. 32:43what should actually go into a Claude or
  823. 32:46Agent MD file?
  824. 32:48A simple rule is like this.
  825. 32:50If removing this instruction would
  826. 32:52probably make Claude assume the wrong
  827. 32:55thing,
  828. 32:56then keep it.
  829. 32:57Otherwise, ask whether Claude really
  830. 33:00needs it in every session.
  831. 33:02For example, inside of our Gucci store,
  832. 33:05we can give it some commands to run.
  833. 33:07Like a package manager is PNPM with the
  834. 33:10start dev server command being PNPM dev.
  835. 33:13And we can also share the commands to
  836. 33:15run the tests or run the type check.
  837. 33:18Later on, once you add the database, we
  838. 33:20can also give it some information such
  839. 33:22as use drizzle for all database access.
  840. 33:25We can specify where the database schema
  841. 33:28lives, such as in source DB schema.
  842. 33:31And we can also tell it to never write
  843. 33:33raw SQL queries unless specifically
  844. 33:36requested. These are some important
  845. 33:37pieces of info. And once we set up the
  846. 33:39storefront design, we can also tell it
  847. 33:42to keep the customer-facing pages
  848. 33:44editorial and product-focused. To reuse
  849. 33:47the existing design system, to avoid the
  850. 33:49dashboard style UI, and to not include
  851. 33:52any of those purple gradients.
  852. 33:55These are useful because they actually
  853. 33:57change how Claude should work.
  854. 34:00Now, compare that with something like
  855. 34:02write high-quality code, follow best
  856. 34:05practices, make the UI beautiful, or
  857. 34:08keep everything clean.
  858. 34:10These sound nice, but they don't really
  859. 34:13tell Claude anything useful. It's the
  860. 34:16same with make the landing page premium.
  861. 34:19But what does that actually mean?
  862. 34:22Instead, you could say use large product
  863. 34:24imagery, generous spacing, and
  864. 34:27restrained controls on storefront pages.
  865. 34:30That's something Claude can actually
  866. 34:32follow. And don't dump your entire
  867. 34:34project structure or huge API
  868. 34:36documentation into Claude or agent MD
  869. 34:38file either. Keep the things Claude
  870. 34:41should know every time it works on this
  871. 34:43project. And the wording matters, too.
  872. 34:46Instead of saying format the code
  873. 34:48properly, say use two space indentation.
  874. 34:52Or instead test your work, say something
  875. 34:55like run pnpm test before finishing the
  876. 34:57task. Or instead of keep the API code
  877. 35:01organized, you can say something like
  878. 35:03API handlers live in source API
  879. 35:06handlers. The more specific you are, the
  880. 35:09less Claude has to guess what you meant.
  881. 35:12And if the file starts becoming huge,
  882. 35:15don't just keep throwing everything at
  883. 35:16it. Claude code also supports the Claude
  884. 35:19rules, where you can split instructions
  885. 35:22into separate files. For example, within
  886. 35:25the dot Claude folder, you can have the
  887. 35:27Claude MD file, and then you can have
  888. 35:29the additional rules folder, within
  889. 35:31which you can have something like
  890. 35:33testing.md, database.md, storefront, or
  891. 35:37security.md.
  892. 35:38You can even make rules apply only to
  893. 35:40certain files by giving it a specific
  894. 35:43path and setting out the rules.
  895. 35:46Now, Claude only needs those rules when
  896. 35:49it's working in matching files.
  897. 35:51That helps you keep the rest of the
  898. 35:53context clear. And if something isn't
  899. 35:55really a rule, but rather a process that
  900. 35:58you keep doing again and again, that
  901. 36:00usually belongs in a skill, but we'll
  902. 36:03get to that later.
  903. 36:05For now, we can create our first Claude
  904. 36:07MD file by running init.
  905. 36:10There's no need to do it from scratch.
  906. 36:12So, just have your Claude window open
  907. 36:14and type init. And as you can see, this
  908. 36:17will initialize a new Claude MD with the
  909. 36:20codebase documentation. It'll pick up
  910. 36:22things like the package manager, the
  911. 36:24framework, the build commands, tests,
  912. 36:26and other project conventions.
  913. 36:29And if you already have a Claude MD, in
  914. 36:31it can suggest changes instead of simply
  915. 36:34replacing it.
  916. 36:35But don't just accept whatever Claude
  917. 36:37creates.
  918. 36:38Read it. Once it's done, you can either
  919. 36:40read it right here, or you can head over
  920. 36:43into the Claude MD or the agent MD file
  921. 36:46that it created. We can then preview it
  922. 36:49either in markdown or with a nice
  923. 36:51previewer like this, which you can
  924. 36:52install as a VS Code extension. Here you
  925. 36:55can see the commands, the architecture,
  926. 36:57the Next JS 16 notes as well.
  927. 37:00It is all here.
  928. 37:02But if Claude added something it can
  929. 37:04easily figure out from package.json, ask
  930. 37:06whether you really need it taking up the
  931. 37:08context every time.
  932. 37:10And if something is wrong, fix it.
  933. 37:12And then add the things that Claude
  934. 37:14couldn't know just by reading the code.
  935. 37:16For example, Claude can see that we are
  936. 37:18using Tailwind, but it can't
  937. 37:20automatically know that we're building a
  938. 37:22Gucci store, which needs to feel
  939. 37:24editorial and product focused, or that
  940. 37:27you don't want a simple dashboard style
  941. 37:29UI.
  942. 37:30That's the kind of information that
  943. 37:32belongs here. And how do you know this
  944. 37:34file is actually getting loaded? Well,
  945. 37:36open up Claude and run context. If you
  946. 37:39do it and then check the memory files,
  947. 37:42you can see the memory right here,
  948. 37:44and you can run {slash} context all to
  949. 37:47expand it.
  950. 37:48That way, you can see exactly where your
  951. 37:51context is being spent.
  952. 37:53And on top of checking the context, you
  953. 37:55can also check the memory.
  954. 37:57And here you can see where it's
  955. 37:58extracting it from. Now, another pro tip
  956. 38:01with the Claude MD file is to not just
  957. 38:04create it once and then forget about it.
  958. 38:07Your project changes, commands change,
  959. 38:09and the architecture changes, too.
  960. 38:11Maybe your database layer lives in one
  961. 38:13folder today, and later you move it
  962. 38:16somewhere else.
  963. 38:17If Claude MD still tells Claude to use
  964. 38:19the old location, you're now giving it
  965. 38:22wrong information before it even starts
  966. 38:24the task. So, keep the file updated.
  967. 38:27Remove things that aren't true anymore,
  968. 38:30and don't keep adding new rules forever,
  969. 38:32either.
  970. 38:33Sometimes, the right change is just
  971. 38:35deleting an old one. And in our Agentic
  972. 38:38engineering workflow, we have a skill
  973. 38:40for that.
  974. 38:42It's called sync. What it does is it
  975. 38:45keeps all the context files up to date.
  976. 38:48It checks your latest Git commits,
  977. 38:50figures out what changed, and updates
  978. 38:52the information automatically across
  979. 38:54your ClaudeMD and AgentMD files
  980. 38:57automatically. So, now that we have this
  981. 38:59ClaudeMD file, Claude knows how you want
  982. 39:02this project to work. But, the next
  983. 39:03question is, how much freedom should you
  984. 39:06give it? When should Claude stop and
  985. 39:09show you a plan first?
  986. 39:11Or, which files should it be allowed to
  987. 39:13touch?
  988. 39:14Which commands should it be allowed to
  989. 39:15run?
  990. 39:16That's where the plan mode and the
  991. 39:18additional permissions come in.
  992. 39:22Thanks to our ClaudeMD, Claude now knows
  993. 39:26how we want this project to be
  994. 39:27structured. So, let's keep building this
  995. 39:29app while learning more of what Claude
  996. 39:32Code can do.
  997. 39:33But, before we do that, there's one
  998. 39:35thing you should check. Look at the
  999. 39:37current Claude Code mode you're in.
  1000. 39:39Claude Code can work with different
  1001. 39:41levels of freedom depending on the mode
  1002. 39:43you're using.
  1003. 39:45There's manual, where Claude asks before
  1004. 39:48actions that need your approval.
  1005. 39:51There's the edit automatically, where
  1006. 39:53normal file edits can happen without
  1007. 39:56asking you every time.
  1008. 39:58There's plan, where Claude can inspect
  1009. 40:01and think through the project without
  1010. 40:03immediately editing your source files.
  1011. 40:05And there's auto, where Claude can
  1012. 40:08approve many actions itself after
  1013. 40:10checking whether they match what you
  1014. 40:12asked it to do. And there are a few
  1015. 40:14other modes for more restricted or
  1016. 40:17isolated workflows, but you don't need
  1017. 40:19them right now. The important thing is
  1018. 40:21to know which mode you're actually
  1019. 40:23using. Because if your Claude code is
  1020. 40:25currently in auto mode, you may see
  1021. 40:28Claude editing files and running things
  1022. 40:30without showing the same permission
  1023. 40:32prompts I'm seeing.
  1024. 40:33That doesn't mean permissions aren't
  1025. 40:35working. It just means you're giving
  1026. 40:36Claude a different level of freedom. And
  1027. 40:39you can cycle between modes right here
  1028. 40:41if you're using the VS Code extension or
  1029. 40:43if you're using it in console,
  1030. 40:46you can just press shift tab to switch
  1031. 40:50between the modes right here. I almost
  1032. 40:52always have it on auto mode on.
  1033. 40:55But for this first feature we'll
  1034. 40:57implement, let's switch it over to
  1035. 40:59manual mode so we can better understand
  1036. 41:01how it's working. And let's start with
  1037. 41:04our first real feature, building the UI
  1038. 41:08of our storefront.
  1039. 41:09Instead of randomly designing pages,
  1040. 41:12let's give Claude an actual reference.
  1041. 41:15We'll use Gucci's current website as
  1042. 41:17inspiration, but we're not copying their
  1043. 41:19branding, assets, or content. So, let's
  1044. 41:22tell it something like study
  1045. 41:26the current Gucci website as a visual
  1046. 41:31reference for this e-commerce
  1047. 41:34application.
  1048. 41:35And of course, that website might be
  1049. 41:37completely different depending on when
  1050. 41:39you're watching this video, but that's
  1051. 41:40totally okay.
  1052. 41:42You might just have a newer design than
  1053. 41:43what I have. And when I'm developing
  1054. 41:45apps myself, I don't typically type.
  1055. 41:49That sounds a bit weird knowing that we
  1056. 41:51all code a lot, but lately I've been
  1057. 41:54more narrating the prompts and the
  1058. 41:56commands for my agent. I use the tool
  1059. 41:59called WhisperFlow, which you can see
  1060. 42:01here at the bottom, but there's many of
  1061. 42:02these different tools that you can use
  1062. 42:04to speak to your agent. Let me show you
  1063. 42:07how that works. I'll press the command
  1064. 42:08key on my keyboard and continue telling
  1065. 42:10it the prompt. Analyze its typography,
  1066. 42:13spacing, layout, navigation, product
  1067. 42:16presentation, imagery, buttons, borders,
  1068. 42:19colors, and responsive behavior without
  1069. 42:22copying its text, assets, or branding.
  1070. 42:25Something like this.
  1071. 42:26Feel free to take your time to copy
  1072. 42:28this.
  1073. 42:29And then I'll say,
  1074. 42:31"Then, implement those principles in our
  1075. 42:33project by setting up the global design
  1076. 42:36system, including typography, color
  1077. 42:39tokens, spacing, containers, buttons,
  1078. 42:42links, borders, and reusable responsive
  1079. 42:45primitives in the appropriate Tailwind
  1080. 42:47and CSS files." And then finally,
  1081. 42:50"Briefly explain the rules you
  1082. 42:52implemented and the files you changed."
  1083. 42:55Now, press enter
  1084. 42:57and watch what happens next. Claude may
  1085. 43:00use web search or web fetch to research
  1086. 43:04that reference.
  1087. 43:05And only then it'll start working within
  1088. 43:08your project.
  1089. 43:09Yep, there we go. Fetch. And it's even
  1090. 43:12using a front-end design skill that I
  1091. 43:14have loaded.
  1092. 43:16And because you're in manual mode,
  1093. 43:17you'll start seeing permission prompts
  1094. 43:20whenever Claude wants to make changes or
  1095. 43:22run commands that need your approval.
  1096. 43:25You might need to approve an edit, then
  1097. 43:27approve another, then Claude might want
  1098. 43:30to do something else, and you need to
  1099. 43:32approve that, too. So, let's give it
  1100. 43:34some time. There we go. Do you want to
  1101. 43:36allow Claude to fetch this content? Yep,
  1102. 43:39we do. Then again, do you want to
  1103. 43:41proceed with this? Yep, we want to
  1104. 43:42proceed with the web search. And
  1105. 43:44throughout the rest of this task, it
  1106. 43:46might ask us to do this a couple of
  1107. 43:48times.
  1108. 43:49Yep. Yep.
  1109. 43:51We want to allow Claude to fetch more
  1110. 43:53websites to figure out exactly what we
  1111. 43:55want.
  1112. 43:56And after some time, you'll start
  1113. 43:58thinking, "Do I really have to approve
  1114. 44:00everything every single time?"
  1115. 44:04And that's where the permissions become
  1116. 44:07useful.
  1117. 44:08Because permissions let you decide what
  1118. 44:11Claude can do automatically, what it
  1119. 44:13should ask you about, and what it
  1120. 44:16shouldn't be allowed to do at all. And
  1121. 44:18there are three basic rule types: allow,
  1122. 44:21ask, and deny. Allow means that Claude
  1123. 44:25can perform that matching action without
  1124. 44:27asking you.
  1125. 44:29Ask means that Claude has to stop and
  1126. 44:31get your approval, and deny means that
  1127. 44:34Claude code blocks it.
  1128. 44:36And if several rules match, Claude
  1129. 44:38checks them in order of deny, ask, and
  1130. 44:41allow. So, deny wins first. You can
  1131. 44:44inspect the permissions that you have
  1132. 44:46with your current project after it
  1133. 44:48finishes doing its thing,
  1134. 44:50and then running permissions.
  1135. 44:52Permissions will show you which
  1136. 44:54permissions you currently have,
  1137. 44:55such as which allow, which ask, deny, or
  1138. 44:59whether it is set to the auto mode with
  1139. 45:01soft allow, soft deny, and so on.
  1140. 45:05So, you can check all of those
  1141. 45:06permissions right here. You might have
  1142. 45:08also noticed that when Claude asked us
  1143. 45:10for permissions,
  1144. 45:12it asked whether we want to allow it
  1145. 45:14once or whether we want to allow it from
  1146. 45:16here onward.
  1147. 45:18So that we don't have to approve that
  1148. 45:20same or similar action again.
  1149. 45:22That's useful because you probably don't
  1150. 45:24need to approve the pnpm build command
  1151. 45:26for the 15th time.
  1152. 45:28But you also shouldn't click don't ask
  1153. 45:30again on everything without thinking
  1154. 45:32about what you're allowing. So, it looks
  1155. 45:34like our design system is in,
  1156. 45:37and we should be able to see it right
  1157. 45:38here within our source,
  1158. 45:41app, and then globals.css.
  1159. 45:43All of the colors, type fonts, and
  1160. 45:46texts, and headings, and buttons, all of
  1161. 45:48it is right here.
  1162. 45:50We'll take a look at that soon, but now
  1163. 45:52let's set up permissions for our store.
  1164. 45:56What would make sense for this project?
  1165. 45:58Well, Claude will probably run commands
  1166. 46:00like pnpm dev, build, test, or type
  1167. 46:04check every now and then. These are
  1168. 46:06normal development checks, and you may
  1169. 46:08want Claude to run them without stopping
  1170. 46:11you each time. But, git push is
  1171. 46:13different. Maybe you always want to see
  1172. 46:16before it happens.
  1173. 46:18And later on, your project will contain
  1174. 46:20things like the database URL or some
  1175. 46:23other environment variables.
  1176. 46:25Claude shouldn't be able to read those.
  1177. 46:28So, you can keep project permission
  1178. 46:30rules inside of the dot Claude folder.
  1179. 46:34If it doesn't exist already, you can
  1180. 46:36create one by creating a new dot Claude.
  1181. 46:40And then within it, you can create a new
  1182. 46:42file called settings.json.
  1183. 46:45For example, inside of there, you can do
  1184. 46:48something like this. Inside of a new
  1185. 46:50JSON object, you can add the permissions
  1186. 46:53and then split them by allow, ask, and
  1187. 46:56deny, just as we talked about.
  1188. 46:59Now, under allow, I gave it permission
  1189. 47:02to run PNPM build, test, run git status,
  1190. 47:05and so on.
  1191. 47:06But, I wanted it to ask before it pushes
  1192. 47:09anything, and I want to explicitly deny
  1193. 47:12that it reads our ENV files.
  1194. 47:15With that, you've created a much more
  1195. 47:17useful baseline. Claude can run the
  1196. 47:20normal checks you'd expect. It will ask
  1197. 47:22before pushing, and your environment
  1198. 47:25files are blocked from its normal
  1199. 47:27access. So, this is where the difference
  1200. 47:29from the previous lesson becomes clear.
  1201. 47:32Inside of the Claude code file, you
  1202. 47:35could write never read .env,
  1203. 47:39and Claude should follow that
  1204. 47:41instruction. But, it's still guidance
  1205. 47:44you're giving to the model.
  1206. 47:46A permission rule set is different. When
  1207. 47:49something matches a deny rule, Claude
  1208. 47:51code itself will block that action. So,
  1209. 47:55use Claude.md for things like, "Hey, use
  1210. 47:58the existing design system when building
  1211. 48:00the storefront pages."
  1212. 48:02But, use permissions for things like,
  1213. 48:05"Claude, you shouldn't read this file."
  1214. 48:08So, Claude MD simply tells Claude how
  1215. 48:12you want it to work. But, permissions
  1216. 48:14decide what Claude code is actually
  1217. 48:17allowed to do. And just like with the
  1218. 48:20code, don't set up permissions and
  1219. 48:22assume everything works. You may not
  1220. 48:24have a real.env yet, so create a
  1221. 48:27temporary example file. Or test that
  1222. 48:30rule later when the database is added.
  1223. 48:32For now, we have this .env.example,
  1224. 48:35but I'll go ahead and copy it and create
  1225. 48:37a new .env and paste what we have in
  1226. 48:40there. And let's assume that this
  1227. 48:42includes the actual password. Now, we
  1228. 48:44can open up Claude and tell it to read
  1229. 48:46the .env and tell me what's inside it.
  1230. 48:49Claude code should block the access.
  1231. 48:53First, it'll ask us to run the bash
  1232. 48:55command because we're still in manual or
  1233. 48:58auto-accept edits mode, but once it
  1234. 49:00reaches that file, it'll say, "I can't.
  1235. 49:03Reading that file is blocked by this
  1236. 49:06session's permission settings. File is
  1237. 49:08in a directory that is denied by your
  1238. 49:10permission settings."
  1239. 49:12I didn't try to route around it with a
  1240. 49:13cat since the deny rule is clearly aimed
  1241. 49:16at .env contents specifically.
  1242. 49:18And you can always run the permissions
  1243. 49:21command to check which rules are under
  1244. 49:23allow, ask, or deny.
  1245. 49:26Now, let's see what the experience feels
  1246. 49:28like with those permissions set.
  1247. 49:31Since we already have a full design
  1248. 49:33system put in place right here within
  1249. 49:36the app.globals.css,
  1250. 49:38we can ask Claude to build the first
  1251. 49:40home page. For example, we can tell it
  1252. 49:43to build the first complete home page
  1253. 49:45for the e-commerce storefront using the
  1254. 49:48design system already set up in the
  1255. 49:50project.
  1256. 49:51We can then continue telling it to take
  1257. 49:54inspiration from the way premium fashion
  1258. 49:56websites like Gucci use large editorial
  1259. 49:59imagery, featured collections, and
  1260. 50:01product focus sections.
  1261. 50:03And finally, we can tell it to use
  1262. 50:05simple sample product and collection
  1263. 50:07data where needed with images from
  1264. 50:09Unsplash or other sources.
  1265. 50:11We want to make it responsive and verify
  1266. 50:13the result when it's done.
  1267. 50:16And run it. Now, if you watch Claude
  1268. 50:19again, it can make the changes it needs
  1269. 50:21and when it wants to run one of the
  1270. 50:23commands you've already allowed, it
  1271. 50:26doesn't need to interrupt you every
  1272. 50:27time. But for some things like running
  1273. 50:30bash commands, it might still ask you
  1274. 50:31for permission. The goal is that you're
  1275. 50:34not trying to remove every permission
  1276. 50:36prompt, but rather you're trying to
  1277. 50:38remove the boring ones that you already
  1278. 50:40understand while keeping control around
  1279. 50:42the things that matter. But to be
  1280. 50:44honest, the auto mode has gotten so
  1281. 50:46advanced that I typically leave it on
  1282. 50:49and I'm totally happy with the amount of
  1283. 50:50permissions that Claude code has by
  1284. 50:52default.
  1285. 50:54So, that's what I'll shift it to by
  1286. 50:56using shift tab. And let's let it finish
  1287. 50:59running this task. And after some time,
  1288. 51:02it is done. Here, it gave us the final
  1289. 51:05explanation of what happened,
  1290. 51:07the files it changed, and so much more.
  1291. 51:11So, what do you say that we run the
  1292. 51:13application for the first time and check
  1293. 51:15it out?
  1294. 51:16I'll open up a secondary terminal and
  1295. 51:19run npm dev as that's what we're using
  1296. 51:22to run the application. And then I'll
  1297. 51:24open it up on localhost 3000.
  1298. 51:26You can either open it up within your
  1299. 51:28browser or nowadays, even VS Code has
  1300. 51:31its built-in browser.
  1301. 51:33Since this is a large-scale
  1302. 51:36pretty well-designed application, I
  1303. 51:38definitely want to open it up within the
  1304. 51:40browser. So, check it out.
  1305. 51:43Complimentary delivery and returns,
  1306. 51:45atelier, and here we have the long coat,
  1307. 51:49as well as some of the additional
  1308. 51:50collections of the printed silk,
  1309. 51:52outerwear, and leather goods.
  1310. 51:55This is looking like a real store. So,
  1311. 51:58just from a single prompt, we were able
  1312. 52:00to get a pretty good output.
  1313. 52:03Of course, the other pages are not going
  1314. 52:04to work right now, like the products
  1315. 52:06page, but that's going to be the next
  1316. 52:08step. For now, we only have the home
  1317. 52:10page, and sure, we can play with the
  1318. 52:12hero section to present it a bit better.
  1319. 52:15But, now I want to be able to open up
  1320. 52:18one of these product detail pages.
  1321. 52:21That's going to be under products, and
  1322. 52:23then the product name. So, back into the
  1323. 52:25application, open up the terminal,
  1324. 52:27head over to Claude, and let's tell it
  1325. 52:30something along the lines of build the
  1326. 52:33product detail page with large imagery,
  1327. 52:35product information, price, category,
  1328. 52:38and stock state. Keep it consistent with
  1329. 52:40the home page and product listing.
  1330. 52:43And run it.
  1331. 52:45I'm running it on auto mode, so now we
  1332. 52:47shouldn't be getting as many permission
  1333. 52:49questions.
  1334. 52:50And a couple of minutes in, the product
  1335. 52:52detail page is built and verified. The
  1336. 52:56build passes, and all 13 product pages
  1337. 52:59pre-render as static HTML with lint
  1338. 53:02being clean. You can see all the files
  1339. 53:04that have been changed right here,
  1340. 53:06information about how the page is
  1341. 53:07structured, and that is it. And all of
  1342. 53:11this only took 21% of the context
  1343. 53:13window. So, let's quickly check it out
  1344. 53:16by re-running our application, opening
  1345. 53:19it up on localhost 3000, and then
  1346. 53:21opening a specific product details page,
  1347. 53:23such as this Jorno soft backpack.
  1348. 53:27A nice product page opens. We can see a
  1349. 53:30static product information on the right,
  1350. 53:32while the images on the left scroll. And
  1351. 53:34then we can see the recommended product
  1352. 53:36section at the bottom. And all of this
  1353. 53:38really feels like a polished editorial
  1354. 53:41Gucci-inspired style website. But, with
  1355. 53:44all of this, we're still not setting up
  1356. 53:46the real database.
  1357. 53:48Right now, we're working on the customer
  1358. 53:49experience and making sure that the
  1359. 53:51design, components, and the page
  1360. 53:54structure feels right.
  1361. 53:56And these are exactly the kind of things
  1362. 53:58where letting Claude edit normally makes
  1363. 54:00sense.
  1364. 54:01If the product grid is wrong, you can
  1365. 54:03easily change it. Or, if you don't like
  1366. 54:05a specific section like this one, you
  1367. 54:08can redesign it. And if the spacing is
  1368. 54:10off, Claude can fix it on its own.
  1369. 54:13These changes are easy to review, and
  1370. 54:16therefore easy to undo as well.
  1371. 54:19And that's how you should approach
  1372. 54:20building with AI in general.
  1373. 54:22Instead of asking it to build the entire
  1374. 54:25store in one prompt, and then wondering
  1375. 54:27what it did, you break the work into
  1376. 54:29small features. Let Claude build one,
  1377. 54:32review it, accept it or undo it, and
  1378. 54:34then move on to the next one. That is
  1379. 54:36what agentic engineering is all about.
  1380. 54:39So, at this point, our atelier is
  1381. 54:41starting to look like an actual
  1382. 54:43e-commerce application.
  1383. 54:44You've got the main project set up, the
  1384. 54:47Claude.md file right here up and running
  1385. 54:50giving Claude instructions, a design
  1386. 54:53system within the globals.css
  1387. 54:56based on a real reference.
  1388. 54:58You also have storefront homepage right
  1389. 55:01here in the page. There's also the
  1390. 55:04product listing pages,
  1391. 55:06as well as project permissions that
  1392. 55:08remove unnecessary approvals while
  1393. 55:10protecting more important sections. And
  1394. 55:13notice how you learned about those
  1395. 55:15permissions. You didn't memorize a
  1396. 55:17settings file and moved on. You saw the
  1397. 55:20problem first.
  1398. 55:21Claude kept asking before it could work.
  1399. 55:24Then, you decided which actions were
  1400. 55:26safe enough to allow, and which ones
  1401. 55:29should still stay under your control.
  1402. 55:31And that's how most of the rest of this
  1403. 55:33course will work, too. So far, the
  1404. 55:35features you build are relatively easy
  1405. 55:37to change.
  1406. 55:38If you don't like the homepage, redesign
  1407. 55:41it.
  1408. 55:41Or if a product card is wrong, just
  1409. 55:44change it.
  1410. 55:45But the next step is different.
  1411. 55:48You need to add the real database layer.
  1412. 55:51That means Postgres, Drizzle, products,
  1413. 55:54categories, inventory, and database
  1414. 55:56migrations. And those decisions are
  1415. 55:58harder to undo casually.
  1416. 56:01And for something like that, you may not
  1417. 56:03want Claude to immediately start writing
  1418. 56:05code the moment you describe the
  1419. 56:07feature.
  1420. 56:08You may want it to inspect the project
  1421. 56:10first and show you exactly what it plans
  1422. 56:13to do.
  1423. 56:14And that's exactly where the plan mode
  1424. 56:19comes into play.
  1425. 56:20So, let's talk about that next.
  1426. 56:24Now, let's use the plan mode on the
  1427. 56:26first part of our e-commerce application
  1428. 56:29where the approach actually matters,
  1429. 56:32which is the real database.
  1430. 56:34You can either approach it through the
  1431. 56:36VS Code extension by selecting the plan
  1432. 56:38mode right here and then tell it what to
  1433. 56:40do, or you can do it through the
  1434. 56:42terminal. If you start a new session,
  1435. 56:45this would be a great place to clear the
  1436. 56:47context,
  1437. 56:48and then you can simply run
  1438. 56:49{forward-slash} plan to enable the plan
  1439. 56:52mode or view the current session plan.
  1440. 56:55Or you can shift to it naturally by
  1441. 56:56holding the shift key and then tapping
  1442. 56:58onto plan mode. Here, we can ask it to
  1443. 57:01inspect the current e-commerce project
  1444. 57:04and plan how to replace the current
  1445. 57:07product data with a real Postgres
  1446. 57:09database using Drizzle ORM.
  1447. 57:12We can also continue to say that for
  1448. 57:14now, we only need products, categories,
  1449. 57:17and stock.
  1450. 57:19We can then ask it to study how the
  1451. 57:21existing storefront currently uses
  1452. 57:23product data before deciding the schema.
  1453. 57:25And since we're just starting off, we
  1454. 57:27want to keep this first version simple.
  1455. 57:29Don't add carts, orders, payments,
  1456. 57:32reviews, wish lists, or product variants
  1457. 57:34yet. And most importantly, we want to
  1458. 57:37ask it to show us the database
  1459. 57:39structure, relationships, files that
  1460. 57:42need to change, migration approach, and
  1461. 57:44how the existing storefront will start
  1462. 57:47using the database.
  1463. 57:49Press enter and watch Claude work.
  1464. 57:53In plan mode, Claude can now inspect,
  1465. 57:56search, and research, but normal source
  1466. 57:59edits stay blocked until you approve the
  1467. 58:01plan.
  1468. 58:02You can see that it started a new agent
  1469. 58:04right here on main, as well as it
  1470. 58:06started a sub-agent on the explore part,
  1471. 58:09where it's exploring how the storefront
  1472. 58:12uses the product data right now. And if
  1473. 58:14you want to see what that sub-agent is
  1474. 58:16doing, you can just head over to it,
  1475. 58:18press enter, and then you can see what
  1476. 58:20that agent is doing right here, or you
  1477. 58:21can go back to the main session. Looks
  1478. 58:23like it already has a clear picture of
  1479. 58:25the current data layer, so it's going to
  1480. 58:27confirm a few schema decisions. And now,
  1481. 58:30Claude got back to us with a couple of
  1482. 58:31questions.
  1483. 58:32How should the stock be represented in
  1484. 58:35the database?
  1485. 58:36Well, it can be quantity plus derived
  1486. 58:38state. Yep, that looks good to me. How
  1487. 58:40should the multiple product images be
  1488. 58:42stored? Well, we can use separate
  1489. 58:44product images table.
  1490. 58:46The home page collection strip, printed
  1491. 58:48silk outerwear leather goods, overlaps
  1492. 58:50with the product categories. Well, those
  1493. 58:52can just be categories.
  1494. 58:54Uh the home page has two hard-coded
  1495. 58:55list. Well, we just want to order it by
  1496. 58:57created at. I basically accepted all the
  1497. 59:00recommended options because in this
  1498. 59:02case, they fit what I was after. So, we
  1499. 59:05can submit the answers and let the agent
  1500. 59:07continue planning. Without these
  1501. 59:09questions, if you just accepted what
  1502. 59:11Claude gave you, and you immediately
  1503. 59:13press approve without actually reading
  1504. 59:15the plan, you've gained almost nothing.
  1505. 59:19The whole point is to catch bad
  1506. 59:21decisions before they become code.
  1507. 59:25For this database, we want to check
  1508. 59:27things like what tables Claude wants to
  1509. 59:30create. How products and categories
  1510. 59:33connect, where the stock is stored and
  1511. 59:36how, how prices are represented, where
  1512. 59:39the drizzle schema will live,
  1513. 59:41which files need to change, and how
  1514. 59:43Claude plans to verify the result.
  1515. 59:46A weak plan might sound something like
  1516. 59:49add database, add products, update
  1517. 59:51storefront, but that doesn't tell you
  1518. 59:54much. A useful plan should show that
  1519. 59:56Claude understood the current
  1520. 59:58application and can name the actual
  1521. 1:00:00parts of the codebase that will change.
  1522. 1:00:03While it's doing its thing, I want to
  1523. 1:00:05give you an example. So, I'll head over
  1524. 1:00:07into our readme,
  1525. 1:00:09and I'll just paste something at the
  1526. 1:00:10top. You can also open it in preview.
  1527. 1:00:13Just imagine that Claude says something
  1528. 1:00:15like this.
  1529. 1:00:16Create separate products, product
  1530. 1:00:18variants, inventory locations, and more.
  1531. 1:00:21You could stop right there and say,
  1532. 1:00:24"That's too much for where it is right
  1533. 1:00:25now. Keep stock directly on the product
  1534. 1:00:29and only create what we currently need."
  1535. 1:00:31That only takes a few seconds, but if
  1536. 1:00:34you catch the same mistake after Claude
  1537. 1:00:36has already created the schema,
  1538. 1:00:38generated migrations, and changed the
  1539. 1:00:40storefront, well, then there's much more
  1540. 1:00:42to undo.
  1541. 1:00:44And that's one of the biggest reasons to
  1542. 1:00:46use the plan mode. The cheapest place to
  1543. 1:00:49fix a wrong decision is in the plan, not
  1544. 1:00:52after the code is written. So, back in
  1545. 1:00:54the terminal, it looks like Claude
  1546. 1:00:57presented us with a plan. The goal is to
  1547. 1:00:59move the catalog into Postgres. It gave
  1548. 1:01:02us context on all of that, the database
  1549. 1:01:04plumbing, and even which files should
  1550. 1:01:06change.
  1551. 1:01:07You should analyze all of this in
  1552. 1:01:09detail. It's specifying which column is
  1553. 1:01:11it going to add, how our database is
  1554. 1:01:13going to be structured, and more. And
  1555. 1:01:15you could even ask it to turn this into
  1556. 1:01:17a markdown file so you can review it
  1557. 1:01:19more nicely. If you want to edit the
  1558. 1:01:20plan directly, you can just press Ctrl G
  1559. 1:01:23to open it up. And once you do that,
  1560. 1:01:26it'll be opened up in a new markdown
  1561. 1:01:28window.
  1562. 1:01:29Here, you can even preview it for a bit
  1563. 1:01:31of a nicer view, and spend some time,
  1564. 1:01:34maybe even 5 to 10 minutes, going over
  1565. 1:01:36the plan and noting down or directly
  1566. 1:01:39changing right here all the things that
  1567. 1:01:41you think should change. And only when
  1568. 1:01:43you're happy with the approach, you can
  1569. 1:01:45approve it.
  1570. 1:01:47One important thing to know is that
  1571. 1:01:49approving the plan exits the plan mode.
  1572. 1:01:52Claude doesn't stay in the same
  1573. 1:01:54read-only state afterward. So, you can
  1574. 1:01:57choose how you want to continue, and
  1575. 1:01:58then Claude moves into the
  1576. 1:02:00implementation. In this case, we can say
  1577. 1:02:02yes, proceed, execute the plan, and use
  1578. 1:02:05auto mode. And that's exactly what it'll
  1579. 1:02:07proceed to do. And one important thing
  1580. 1:02:09to know is that approving the plan exits
  1581. 1:02:12the plan mode. As you can see on my end
  1582. 1:02:15right here, it finished, and we're back
  1583. 1:02:18in the auto mode. Now, in this plan, or
  1584. 1:02:21the execution of the plan, we set some
  1585. 1:02:24very important foundations for the rest
  1586. 1:02:26of the application.
  1587. 1:02:27And that's something that's not only
  1588. 1:02:30useful for this one task, but something
  1589. 1:02:33that Claude should probably remember
  1590. 1:02:34every time it works on this database.
  1591. 1:02:37So, we can tell Claude to update the
  1592. 1:02:40Claude.md with only the database
  1593. 1:02:43conventions from this decision that
  1594. 1:02:45Claude should remember in future
  1595. 1:02:46sessions. It'll take a look at what it
  1596. 1:02:48did, and it'll read and then update the
  1597. 1:02:51Claude.md. We want to keep it short and
  1598. 1:02:53don't add things that Claude can easily
  1599. 1:02:55discover from the code base.
  1600. 1:02:57It might end up with, just as you can
  1601. 1:03:00see right here, an additional seed
  1602. 1:03:02command,
  1603. 1:03:03as well as some database-specific
  1604. 1:03:05configurations, such as where the
  1605. 1:03:07schemas are stored, the catalog, and so
  1606. 1:03:10much more. And that's it. This is
  1607. 1:03:12exactly how Claude.md should grow.
  1608. 1:03:14Not because you want a bigger file, but
  1609. 1:03:17because the project has now made a real
  1610. 1:03:19decision that Claude should remember.
  1611. 1:03:21And if Claude keeps making the same
  1612. 1:03:23wrong assumption every time you plan
  1613. 1:03:25something, that's usually a sign that
  1614. 1:03:27your project instructions are either
  1615. 1:03:29missing or are wrong. Okay, so as we
  1616. 1:03:32approved the plan, Claude went into
  1617. 1:03:35building. We can zoom out a bit because
  1618. 1:03:37there's a lot of stuff that happened
  1619. 1:03:38right here, and we can read its update.
  1620. 1:03:41Claude first configured drizzle, then it
  1621. 1:03:44created three additional tables and
  1622. 1:03:46schemas for them. It set up a database
  1623. 1:03:48connection, generated migrations,
  1624. 1:03:51created seed data, so we can seed our
  1625. 1:03:54database. It updated the product
  1626. 1:03:56queries, and connected the storefront to
  1627. 1:03:59Postgres.
  1628. 1:04:00The important part is that Claude isn't
  1629. 1:04:02inventing the direction anymore. It's
  1630. 1:04:05implementing the approach that we
  1631. 1:04:06reviewed. But at some point, you'll need
  1632. 1:04:09a real Postgres connection string. So,
  1633. 1:04:12let's create a database using any kind
  1634. 1:04:14of a provider.
  1635. 1:04:15In this case, I'll use Neon as it's free
  1636. 1:04:18and easiest to set up.
  1637. 1:04:20So, simply create your account. You can
  1638. 1:04:22use any provider.
  1639. 1:04:25Then, create a new project. Let's call
  1640. 1:04:28it Atelier
  1641. 1:04:29Store.
  1642. 1:04:31You can choose the region that is
  1643. 1:04:32closest to you.
  1644. 1:04:34And just click create project. The
  1645. 1:04:36project was created, so you can head
  1646. 1:04:38over into it. Then, click connect. And
  1647. 1:04:41here, you'll be able to connect your
  1648. 1:04:42database. Simply copy this connection
  1649. 1:04:44string.
  1650. 1:04:46Head back into the application under the
  1651. 1:04:48.env.
  1652. 1:04:50Or in this case, we can rename it to
  1653. 1:04:51.env.local
  1654. 1:04:53because that is the .env that we're
  1655. 1:04:55going to use locally on this device. And
  1656. 1:04:57then here, we can update the database
  1657. 1:04:59URL with the one we just copied. You
  1658. 1:05:02don't want to paste the secret into
  1659. 1:05:03Claude.
  1660. 1:05:05Instead, you want to add it here, and
  1661. 1:05:07we'll use that to run the application,
  1662. 1:05:09but we'll never tell it to Claude. And
  1663. 1:05:12now we want to test the whole database
  1664. 1:05:14end to end. Such as running migrations
  1665. 1:05:17right here that were generated and
  1666. 1:05:18inspected for us.
  1667. 1:05:20Claude should have created a command for
  1668. 1:05:22us in order to be able to do that. I
  1669. 1:05:24believe the command in question is the
  1670. 1:05:26one that it added to Claude. So we can
  1671. 1:05:28even tell it to run the migration and
  1672. 1:05:30seed now that the database URL is set.
  1673. 1:05:33And I love how it auto recommended that
  1674. 1:05:35line for us.
  1675. 1:05:37It's going to check what's in the
  1676. 1:05:38database. It'll create a script and very
  1677. 1:05:41soon it'll run that script. But in the
  1678. 1:05:44meantime it says that it can't run it
  1679. 1:05:46because database URL isn't reaching my
  1680. 1:05:48shell.
  1681. 1:05:49Maybe it is specifically looking for
  1682. 1:05:51.env and not .env.local.
  1683. 1:05:54So I'll remove that .env part and tell
  1684. 1:05:57it to try again.
  1685. 1:06:00There we go. It got connected and the
  1686. 1:06:03database is empty with no auth tables.
  1687. 1:06:05So our first migration applies cleanly.
  1688. 1:06:08Great. Now it'll verify whether data
  1689. 1:06:10landed correctly, but we can also verify
  1690. 1:06:12on our end by heading over into Neon
  1691. 1:06:16tables
  1692. 1:06:17and you can see the account, categories,
  1693. 1:06:19products. All of the data is actually
  1694. 1:06:22right here.
  1695. 1:06:24We can even verify an image I believe if
  1696. 1:06:28we find where the images are stored.
  1697. 1:06:32There we go, product images.
  1698. 1:06:34And here we can see the URLs from
  1699. 1:06:36Unsplash.
  1700. 1:06:37So if you were to copy this entire URL
  1701. 1:06:40you would be able to see the image. But
  1702. 1:06:42we'll see it in our application soon. So
  1703. 1:06:44with that in mind, we can now actually
  1704. 1:06:46run our application by opening up the
  1705. 1:06:48terminal and running pnpm dev to spin it
  1706. 1:06:51up on localhost 3000. So back in the
  1707. 1:06:53browser, heading over to localhost 3000
  1708. 1:06:57if you reload, you should be able to see
  1709. 1:06:59the application and it looks very
  1710. 1:07:01similar as it did before, but now it's
  1711. 1:07:05actually pulling the real data from the
  1712. 1:07:08database. And that's the beauty of it.
  1713. 1:07:10So, before we proceed, we can now open
  1714. 1:07:13up Claude and tell it to show me the
  1715. 1:07:15important changes you made and explain
  1716. 1:07:18anything that I should review carefully.
  1717. 1:07:22Or you can run git diff in your
  1718. 1:07:25terminal. Maybe I can open up another
  1719. 1:07:26one. And this will tell us all the file
  1720. 1:07:28changes that happened recently. You can
  1721. 1:07:30also explore them right here.
  1722. 1:07:33But yeah, let's see what Claude itself
  1723. 1:07:35thinks that we should review. And there
  1724. 1:07:37we go. Here's the walk-through. The
  1725. 1:07:39important changes. Stock became a number
  1726. 1:07:42and the states became derived. So, here
  1727. 1:07:45we can see how we are handling the state
  1728. 1:07:47behavior of how many items do we have in
  1729. 1:07:50stock available to order.
  1730. 1:07:52Before sold out was typed by hand per
  1731. 1:07:54product. Now, nothing stores a state.
  1732. 1:07:57Two columns do and every badge, tone,
  1733. 1:08:00and disabled button follows them.
  1734. 1:08:02Two. One mapper is the same between the
  1735. 1:08:05database and the UI. So, in this case,
  1736. 1:08:07we have the price, the compare at price,
  1737. 1:08:09the images, the badge, and the stock.
  1738. 1:08:11And every query returns the product
  1739. 1:08:13data, never a row. And that's why a
  1740. 1:08:16product card and the detail page JSX are
  1741. 1:08:18left untouched since nulls and foreign
  1742. 1:08:21keys stop here. And there's a couple
  1743. 1:08:23more things that we should review
  1744. 1:08:24carefully. In this case, plan mode
  1745. 1:08:27helped us catch the wrong direction
  1746. 1:08:29early. But it still doesn't replace
  1747. 1:08:32reviewing what was actually built.
  1748. 1:08:34If Claude starts drifting, replan by
  1749. 1:08:37going back into the plan mode and then
  1750. 1:08:40update the approach based on the new
  1751. 1:08:41information.
  1752. 1:08:43That's better than letting a wrong
  1753. 1:08:44direction spread across the project and
  1754. 1:08:47trying to clean it up afterward. But
  1755. 1:08:49before we keep building, there's one
  1756. 1:08:51thing I want to talk about. It's
  1757. 1:08:53security. And this has become a
  1758. 1:08:55genuinely wild topic recently. In July
  1759. 1:08:582026, OpenAI disclosed that two of its
  1760. 1:09:02models, during an internal cybersecurity
  1761. 1:09:05evaluation, escaped their sandbox
  1762. 1:09:08testing environment by exploiting a
  1763. 1:09:11zero-day vulnerability,
  1764. 1:09:13reached the internet, and compromised
  1765. 1:09:15parts of the Hugging Face's production
  1766. 1:09:17infrastructure. And the reason for that?
  1767. 1:09:20They were trying to find answers so they
  1768. 1:09:23could cheat on the benchmark they were
  1769. 1:09:25being evaluated on. Yep, I'm not joking.
  1770. 1:09:29A week later, Anthropic reviewed its own
  1771. 1:09:32cybersecurity evaluations and found
  1772. 1:09:35incidents where Claude models had gained
  1773. 1:09:37unauthorized access to the real systems
  1774. 1:09:40of other organizations. By September,
  1775. 1:09:43that count was up to four incidents
  1776. 1:09:46found across a review of roughly 480
  1777. 1:09:50million transcripts. So, apparently, the
  1778. 1:09:53AI is not only writing your back end
  1779. 1:09:55anymore. Sometimes, it's also trying to
  1780. 1:09:58find its way out of the building.
  1781. 1:10:01Obviously, these were very unusual
  1782. 1:10:03evaluation environments with safety
  1783. 1:10:05measures reduced for testing, not Claude
  1784. 1:10:08code randomly attacking websites from
  1785. 1:10:10someone's laptop. But, it does make one
  1786. 1:10:12thing very clear. As AI starts writing
  1787. 1:10:15more of your application, security
  1788. 1:10:18matters even more. And there's another
  1789. 1:10:20problem. Claude just helped us plan this
  1790. 1:10:24database implementation. Claude wrote
  1791. 1:10:27most of the code. Now, technically, I
  1792. 1:10:30could ask Claude to check whether the
  1793. 1:10:32code that it just wrote is secure, and
  1794. 1:10:35it absolutely can find useful issues.
  1795. 1:10:38But, for important security checks, I
  1796. 1:10:41don't love the idea of having the same
  1797. 1:10:44model that made the implementation
  1798. 1:10:46decisions be the only model judging
  1799. 1:10:49those same decisions afterward. I want
  1800. 1:10:52another pair of eyes, and that's where I
  1801. 1:10:54use Code Rabbit. They've sponsored this
  1802. 1:10:57segment of the video to show you a
  1803. 1:10:58feature that's especially useful at this
  1804. 1:11:01stage. And it's called AI Deep Scan.
  1805. 1:11:04Instead of only reviewing a single
  1806. 1:11:06change, Deep Scan can inspect committed
  1807. 1:11:09code across the repository and look for
  1808. 1:11:12security risks across the application.
  1809. 1:11:15And this is a good time to run it
  1810. 1:11:17because we've just introduced our first
  1811. 1:11:19real back-end and data layer. To be able
  1812. 1:11:22to test it, we have to commit our work
  1813. 1:11:24and push it over to GitHub. So, head
  1814. 1:11:26over to github.com/new
  1815. 1:11:29and create a new repository. I'll call
  1816. 1:11:32an Atelier Store and I'll create it
  1817. 1:11:34under my own profile. Once it is done,
  1818. 1:11:37we can copy the URL and we can tell
  1819. 1:11:39Claude to commit and push all the
  1820. 1:11:42existing code to this GitHub repo. And
  1821. 1:11:46it should be able to do that nicely for
  1822. 1:11:48us, but we want to turn on the plan mode
  1823. 1:11:51when we run that. And just switch over
  1824. 1:11:53to auto mode.
  1825. 1:11:54And I like how it's going to check
  1826. 1:11:56whether the .env is not included as part
  1827. 1:11:59of the push. While that is happening,
  1828. 1:12:01you can head over to Code Rabbit by
  1829. 1:12:03clicking the link in the description.
  1830. 1:12:05You can start using it completely for
  1831. 1:12:07free, but I've also got a special
  1832. 1:12:09discount code for you. You can use JSMCR
  1833. 1:12:13as the discount code, and the first 50
  1834. 1:12:15new users will get Code Rabbit Pro Plus
  1835. 1:12:18completely for free, which also gives
  1836. 1:12:20you more deep scan runs for bigger, more
  1837. 1:12:22ambitious projects. So, grab it while
  1838. 1:12:25all those spots are available. But for
  1839. 1:12:26now, let's go ahead and sign in using
  1840. 1:12:29GitHub. Once you're there, you can
  1841. 1:12:31connect a repository by adding it right
  1842. 1:12:33here.
  1843. 1:12:34In this case, I'm going to give it
  1844. 1:12:35access to the specific repository, the
  1845. 1:12:38Atelier Store, and I'll click install
  1846. 1:12:41and authorize. Once it's there, you
  1847. 1:12:43should be able to see it right here.
  1848. 1:12:45Now, back on the VS Code side, as you
  1849. 1:12:47can see, as per our rule, it's asking us
  1850. 1:12:51whether we want to allow to push over to
  1851. 1:12:53GitHub, which I'll say yes.
  1852. 1:12:55It pushed over to main, so if you head
  1853. 1:12:57over here, you should be able to see all
  1854. 1:12:59your code right here.
  1855. 1:13:01You can clean it up a bit by hiding the
  1856. 1:13:03releases, deployments, and packages,
  1857. 1:13:05giving it a short description such as a
  1858. 1:13:07luxury brand storefront.
  1859. 1:13:11We can enter the website. As soon as we
  1860. 1:13:13deploy it, we'll be able to enter the
  1861. 1:13:15real deployed URL. For now, I'll put the
  1862. 1:13:17link to jsmasters.com.
  1863. 1:13:19And here you can put something like
  1864. 1:13:21Next.js, Cloud, or whatever else you
  1865. 1:13:24want to add. Then head over to Code
  1866. 1:13:26Rabbit.
  1867. 1:13:27And under security, you can head over to
  1868. 1:13:30AI Deep Scan. Currently, we have three
  1869. 1:13:33deep scans, so let's scan a repository.
  1870. 1:13:36In this case, we're going to pick the
  1871. 1:13:38one that I chose. Some estimated credits
  1872. 1:13:40are going to be right here, and then we
  1873. 1:13:42can scan it. The scan has started, and
  1874. 1:13:45we can see that right here.
  1875. 1:13:47Now, there's one thing that I want to
  1876. 1:13:48point out right here. And that is that
  1877. 1:13:50I'm not going to intentionally introduce
  1878. 1:13:52a vulnerability just so something
  1879. 1:13:54dramatic appears on screen.
  1880. 1:13:56I want to see what it finds in the
  1881. 1:13:58application that we've genuinely built
  1882. 1:14:00using Cloud. Deep Scan will look across
  1883. 1:14:03a repository rather than only examining
  1884. 1:14:06one isolated file or diff, so it can
  1885. 1:14:09reason about how different parts of the
  1886. 1:14:11application connect and surface security
  1887. 1:14:13problems that may span several files.
  1888. 1:14:17Now, let's give it some time until it
  1889. 1:14:18finishes. Now, about 10 minutes in, the
  1890. 1:14:21deep search is now complete. So, let's
  1891. 1:14:24open it up and take a look at what it
  1892. 1:14:26found. If we expand the scan details, we
  1893. 1:14:29can see three findings. One medium, two
  1894. 1:14:32low. No secrets were leaked, but under
  1895. 1:14:35vulnerabilities, we can see three. And
  1896. 1:14:38what's funny is that earlier I said that
  1897. 1:14:40I wasn't going to plant a vulnerability
  1898. 1:14:42just to have something dramatic on the
  1899. 1:14:44screen, but it turns out I didn't need
  1900. 1:14:47to. These are real findings in code that
  1901. 1:14:51we genuinely built in this video. Don't
  1902. 1:14:53just look at the count and panic, and
  1903. 1:14:55don't automatically tell Claude to fix
  1904. 1:14:58everything. We want to triage first.
  1905. 1:15:00Let's start with the highest severity,
  1906. 1:15:03and for each finding, decide is this
  1907. 1:15:05real? Is it relevant? And does it need
  1908. 1:15:08fixing now?
  1909. 1:15:10The first finding is the weak secret.
  1910. 1:15:14This medium finding right here says that
  1911. 1:15:16the application accepts any better off
  1912. 1:15:20secret without checking whether it's
  1913. 1:15:22actually a strong secret. Now, why does
  1914. 1:15:25that matter? Well, that secret signs
  1915. 1:15:28authentication tokens. If a deployment
  1916. 1:15:30ever uses something guessable there, an
  1917. 1:15:33attacker can forge those tokens. And
  1918. 1:15:36Code Rabbit even traced the specific
  1919. 1:15:38path a forged change email verification
  1920. 1:15:41token that ends with the attacker owning
  1921. 1:15:44the victim's account.
  1922. 1:15:45Notice what kind of finding this is.
  1923. 1:15:47There is no bug in our code today. It's
  1924. 1:15:50a missing guardrail, and it becomes a
  1925. 1:15:52real vulnerability the day someone
  1926. 1:15:54deploys this with a lazy secret.
  1927. 1:15:56Exploitability right here is marked
  1928. 1:15:58difficult, but the impact is account
  1929. 1:16:01takeover, which is why it's the only
  1930. 1:16:03medium in this list. And there's a bit
  1931. 1:16:06of irony right here because our
  1932. 1:16:08permission rules stopped Claude from
  1933. 1:16:10ever reading the secret, but nothing in
  1934. 1:16:13the application ever checked whether the
  1935. 1:16:15secret is any good. So, let's bring this
  1936. 1:16:17into Claude code.
  1937. 1:16:19What you can do is just say fix right
  1938. 1:16:21here, and if you have fixed enabled for
  1939. 1:16:23this organization, Claude code will be
  1940. 1:16:25able to automatically apply it. Else,
  1941. 1:16:28you can just share this for agents, head
  1942. 1:16:30over into Claude code by opening the
  1943. 1:16:32terminal, and then pasting it in. It
  1944. 1:16:35explains what the issue is,
  1945. 1:16:38and specifies how to fix it. You can
  1946. 1:16:41either pass it in like that or just tell
  1947. 1:16:43it something like this. The application
  1948. 1:16:46accepts any explicitly configured better
  1949. 1:16:48auth secret. While the authentication
  1950. 1:16:50dependency only warns about short or low
  1951. 1:16:53entropy values. A guessable shared
  1952. 1:16:55secret allows attackers to forge
  1953. 1:16:57authentication-related tokens. And then
  1954. 1:16:59we can ask it to investigate whether
  1955. 1:17:01this is accurate for our own current
  1956. 1:17:03better auth setup and explain the risk
  1957. 1:17:05in the context of this application first
  1958. 1:17:08without modifying anything yet.
  1959. 1:17:10In your case, it's going to be enough if
  1960. 1:17:12you just copy this and paste it in. But
  1961. 1:17:14I want to investigate this first and
  1962. 1:17:16then get back to you with more
  1963. 1:17:17information on whether this really is
  1964. 1:17:20that critical. And then if Claude
  1965. 1:17:22confirms it, we can easily fix it. Very
  1966. 1:17:24quickly, the answer is in. It told me
  1967. 1:17:27that it traced this through the
  1968. 1:17:28installed better auth source. The report
  1969. 1:17:30is partly accurate. The mechanism is
  1970. 1:17:32real, but its premise doesn't match this
  1971. 1:17:34deployment and it understates one thing
  1972. 1:17:37while oversaturating another.
  1973. 1:17:39The mechanism is real. It found it. It
  1974. 1:17:41means a session for the victim and
  1975. 1:17:43rewrites their email. So anyone who
  1976. 1:17:46knows the secret forges that token and
  1977. 1:17:49takes that account over.
  1978. 1:17:51One thing that the report gets more
  1979. 1:17:52right than I'd guessed is that this
  1980. 1:17:54branch never checks the option user
  1981. 1:17:56change email enabled as that gate only
  1982. 1:17:59exists on post change email.
  1983. 1:18:01But that premise is wrong for us and the
  1984. 1:18:03reality is worse.
  1985. 1:18:05The report describes any explicitly
  1986. 1:18:07configurable guessable secret and we
  1987. 1:18:09don't have one. Better auth secret is
  1988. 1:18:11present but empty. So create context
  1989. 1:18:14falls through. That's a default secret,
  1990. 1:18:17an exported constant in the
  1991. 1:18:19in the published NPM package. It's
  1992. 1:18:21publicly known. So this definitely is
  1993. 1:18:24something to fix. We currently don't
  1994. 1:18:26have any users, but as soon as we make
  1995. 1:18:28this application live, this is a real
  1996. 1:18:30risk. So let's simply tell it to fix it.
  1997. 1:18:34And there Here go. The vulnerability is
  1998. 1:18:36now fixed. Now, if the secret is unset,
  1999. 1:18:39we'll get this result. If it's the
  2000. 1:18:41default, we'll say that this is not
  2001. 1:18:43good. If it's under 32 characters, we'll
  2002. 1:18:45say must be at least 32. And if it's a
  2003. 1:18:48repeated filler, well, we can also
  2004. 1:18:50disqualify it. So, it'll only work if
  2005. 1:18:53it's an OpenSSL randomized base 64
  2006. 1:18:5632-character string. Perfect. So, let's
  2007. 1:18:59generate one by heading over into a new
  2008. 1:19:02terminal and run OpenSSL rand base 64.
  2009. 1:19:06This will give you a string which we can
  2010. 1:19:08now put into our .env under the better
  2011. 1:19:11auth secret and it'll work. So, we can
  2012. 1:19:14consider this one fixed. Now, the next
  2013. 1:19:16finding is a low severity and honestly,
  2014. 1:19:20I really like it.
  2015. 1:19:21The home page has a newsletter sign up
  2016. 1:19:23form. So, when Claude built that page
  2017. 1:19:26back in the permission lesson, it
  2018. 1:19:28scaffolded the form with the action
  2019. 1:19:31hash.
  2020. 1:19:32Something that looks like this.
  2021. 1:19:35And it has no method.
  2022. 1:19:37It's just placeholder code, but HTML has
  2023. 1:19:40a default. A form without a method
  2024. 1:19:43submits a get request, which means that
  2025. 1:19:46every email address typed into that form
  2026. 1:19:48gets appended to the URL. Into the
  2027. 1:19:51address bar, the browser history, and
  2028. 1:19:53our server logs. So, think about what
  2029. 1:19:56just happened.
  2030. 1:19:57AI-generated placeholder code sitting on
  2031. 1:20:00the home page quietly leaking subscriber
  2032. 1:20:02emails.
  2033. 1:20:04I mean, nothing crashed per se, but this
  2034. 1:20:06is exactly the kind of thing that an
  2035. 1:20:08independent scan catches.
  2036. 1:20:10And with a click of And if I took a
  2037. 1:20:12quick glance, I would have missed it.
  2038. 1:20:15So, I'm going to share this for agent.
  2039. 1:20:17And then back into the Claude code
  2040. 1:20:19terminal,
  2041. 1:20:21we can just paste it and we'll tell it
  2042. 1:20:23to fix it.
  2043. 1:20:24Fix this, but before I run it, I also
  2044. 1:20:27want to take a look at the next one.
  2045. 1:20:30That's going to be the last one right
  2046. 1:20:31here about information disclosure. And
  2047. 1:20:34right now what's happening is that
  2048. 1:20:36signing up with an email that already
  2049. 1:20:37has an account returns a specific error
  2050. 1:20:40while a new email succeeds. So, anyone
  2051. 1:20:43can probe our sign-up endpoint and
  2052. 1:20:45figure out which email addresses have
  2053. 1:20:48accounts on this store.
  2054. 1:20:50Is that a real issue? Yep. Is it
  2055. 1:20:53critical for us today? Well, that is
  2056. 1:20:55where you have to think instead of just
  2057. 1:20:57auto fix it.
  2058. 1:20:59The complete fix is requiring email
  2059. 1:21:01verification so that every sign-up
  2060. 1:21:03attempt looks identical from the
  2061. 1:21:05outside.
  2062. 1:21:06But, that needs an email sender which we
  2063. 1:21:08deliberately kept out of this build for
  2064. 1:21:10now. If you just add an email service
  2065. 1:21:13onto this project right now mid-lesson
  2066. 1:21:15just to close a low severity finding,
  2067. 1:21:17well, that'll be exactly the kind of
  2068. 1:21:19scope creep that we've been avoiding all
  2069. 1:21:22this course. So, an honest engineering
  2070. 1:21:24answer is that not every finding gets
  2071. 1:21:27fixed the moment it appears. Some get
  2072. 1:21:30fixed now like the one that I sent over
  2073. 1:21:32Claude to fix. The first medium one and
  2074. 1:21:35the second low severity one, but some
  2075. 1:21:37will get a note that I will keep either
  2076. 1:21:40in my mind or on a post-it next to me
  2077. 1:21:42and then later on we can fix it. But,
  2078. 1:21:45what you never want to do is just
  2079. 1:21:47silently ignore it.
  2080. 1:21:49Okay, so let's summarize what just
  2081. 1:21:51happened here. Code Rabbit found three
  2082. 1:21:53issues and explained exactly why each
  2083. 1:21:56one matters. Claude then investigated
  2084. 1:21:58each one inside the code base, confirmed
  2085. 1:22:01them, and implemented the fixes.
  2086. 1:22:04And you made the decision in between
  2087. 1:22:06whether to fix now or document it for
  2088. 1:22:09later. That's two independent systems
  2089. 1:22:11and you are in the middle. It's a much
  2090. 1:22:14healthier setup than just letting one
  2091. 1:22:16model write the entire application and
  2092. 1:22:18then asking it, is everything good? So,
  2093. 1:22:20after it implemented, let's just go
  2094. 1:22:22ahead and tell it to commit and push the
  2095. 1:22:26changes.
  2096. 1:22:27This will now be chained, so as soon as
  2097. 1:22:29it is done, we'll be able to take a look
  2098. 1:22:30at the code changes on GitHub. And
  2099. 1:22:32alongside this, Code Rabbit also reviews
  2100. 1:22:35pull request as code comes in. For
  2101. 1:22:38bigger teams, there's also triage, which
  2102. 1:22:41surfaces the changes that need attention
  2103. 1:22:43first. So, go ahead and check out all
  2104. 1:22:45that it does. I personally use Code
  2105. 1:22:47Rabbit on jsmastery.com.
  2106. 1:22:49That's our official platform repo, so I
  2107. 1:22:52highly recommend it. The link is going
  2108. 1:22:54to be in the description. But now, as
  2109. 1:22:56we're pushing the final changes, I want
  2110. 1:22:58to quickly continue where we left off.
  2111. 1:23:00And if I remember correctly, that was
  2112. 1:23:03the talk about context window and
  2113. 1:23:05context wrought. In this case, we've
  2114. 1:23:08been speaking with this particular agent
  2115. 1:23:10for a long time.
  2116. 1:23:13And sure, we still haven't filled out
  2117. 1:23:15more than 20% of its context window, but
  2118. 1:23:18I think it's about time that we reduce
  2119. 1:23:20the clutter because we are done with
  2120. 1:23:22fixing the security issues. So, there
  2121. 1:23:24are two options. You can either use
  2122. 1:23:27compact,
  2123. 1:23:29which frees up the context by
  2124. 1:23:30summarizing the conversation so far,
  2125. 1:23:33or you can also run clear, which we have
  2126. 1:23:36seen before. This Claude session did a
  2127. 1:23:38lot, so let's go ahead and compact it.
  2128. 1:23:41This will keep the useful parts of the
  2129. 1:23:43current work while reducing the amount
  2130. 1:23:45of conversation that Claude is carrying.
  2131. 1:23:49It'll take some time, and then you'll
  2132. 1:23:51still be able to continue on the same
  2133. 1:23:52conversation but with less clutter. To
  2134. 1:23:55be honest, I don't use compact as often.
  2135. 1:23:59You only want to use this when you're
  2136. 1:24:01working on the same work, but you need
  2137. 1:24:03smaller context. But in most cases, when
  2138. 1:24:06you fill up the context, you'll already
  2139. 1:24:08be done with the feature implementing,
  2140. 1:24:10so you can just run clear and start from
  2141. 1:24:13a new session. And in this lesson, the
  2142. 1:24:15thing that filled up the context was us
  2143. 1:24:18using the plan mode to plan our entire
  2144. 1:24:20database. But while we're compacting the
  2145. 1:24:23conversation right here, I want to tell
  2146. 1:24:25you to not use the plan mode for
  2147. 1:24:28everything.
  2148. 1:24:29If the task is something like change the
  2149. 1:24:31heading or add more spacing here,
  2150. 1:24:34just do it. Plan mode is useful when the
  2151. 1:24:36approach itself needs to review.
  2152. 1:24:39Things like the database changes,
  2153. 1:24:41authentication, migrations, large
  2154. 1:24:44refactors, or changes across several
  2155. 1:24:47parts of the system.
  2156. 1:24:48But, if the change is obvious, don't add
  2157. 1:24:51another step just because the plan mode
  2158. 1:24:52exists. And for more complex things,
  2159. 1:24:55there's something on top of plan mode.
  2160. 1:24:58Uh let me explain this in a read me
  2161. 1:25:00right here. Plan mode works well when
  2162. 1:25:02you already know what you want and
  2163. 1:25:04Claude needs to figure out how to
  2164. 1:25:06implement it.
  2165. 1:25:07Something like add products, categories,
  2166. 1:25:10and stock using Postgres and Drizzle.
  2167. 1:25:13That's clear enough. But, something like
  2168. 1:25:15build proper inventory management is
  2169. 1:25:19much more vague.
  2170. 1:25:20Does it mean multiple warehouses,
  2171. 1:25:23reservations,
  2172. 1:25:25low stock alerts,
  2173. 1:25:28inventory history, or more?
  2174. 1:25:30Well, that's where I separate the
  2175. 1:25:32problem further inside of Agentic
  2176. 1:25:34Engineering skills.
  2177. 1:25:36As I told you already, it's an open
  2178. 1:25:38source repo.
  2179. 1:25:39And specifically, the skill in question
  2180. 1:25:41right here would be the scope skill. So,
  2181. 1:25:45head over here into scope just to show
  2182. 1:25:47you.
  2183. 1:25:48And what the scope skill does is to turn
  2184. 1:25:51a product idea into a living core scope
  2185. 1:25:54in the doc scope and keep it current.
  2186. 1:25:57You can use it for planning a new
  2187. 1:25:59product or a new slice, which would be a
  2188. 1:26:01feature. You can use it to plan one
  2189. 1:26:03feature specifically, or run it with no
  2190. 1:26:06arguments to reconcile after shipping
  2191. 1:26:08and queue what is next. So, basically,
  2192. 1:26:10it's a seed for what to build.
  2193. 1:26:14Then, there's also the architect skill,
  2194. 1:26:16which works with you through the
  2195. 1:26:17important technical decisions, and then
  2196. 1:26:20the develop skill that builds. So,
  2197. 1:26:22basically, we use the scope skill to
  2198. 1:26:25challenge the idea before writing any
  2199. 1:26:28code.
  2200. 1:26:29Then, we use the architect skill, this
  2201. 1:26:32one right here,
  2202. 1:26:34to ask what important technical
  2203. 1:26:36decisions need to be made. And finally,
  2204. 1:26:39we can use the plan mode to check how
  2205. 1:26:41should this specific change be
  2206. 1:26:43implemented into the current code base.
  2207. 1:26:46You don't need all of these at every
  2208. 1:26:48step for every feature.
  2209. 1:26:50But once you're working on larger
  2210. 1:26:52applications, that separation becomes
  2211. 1:26:54really useful. The workflow itself is
  2212. 1:26:57completely free and open source, but if
  2213. 1:26:59you want to learn how to use it with
  2214. 1:27:00Claude Code,
  2215. 1:27:02then you can check out the Agentic
  2216. 1:27:04Engineering course.
  2217. 1:27:05At this point, all the pieces you've
  2218. 1:27:07learned are starting to work together.
  2219. 1:27:09Claude and D keeps the important project
  2220. 1:27:12rules.
  2221. 1:27:13Permissions, right here, control what
  2222. 1:27:15Claude can or must not do.
  2223. 1:27:18Plan mode lets you review important
  2224. 1:27:21changes before implementation. Compact
  2225. 1:27:23helps when a long task starts filling
  2226. 1:27:25the context. You can run context to see
  2227. 1:27:29what is filling the context, and
  2228. 1:27:31finally, the clear command gives you a
  2229. 1:27:33fresh start when the new task is
  2230. 1:27:35unrelated. That's the pattern you want
  2231. 1:27:38to build.
  2232. 1:27:39Knowing when each one is useful while
  2233. 1:27:42you're actually building.
  2234. 1:27:45At this point, you've already built
  2235. 1:27:48several parts of our luxury storefront,
  2236. 1:27:51and you're probably [clears throat]
  2237. 1:27:52starting to notice something. The
  2238. 1:27:54features change, but a lot of the
  2239. 1:27:56process doesn't. When Claude builds
  2240. 1:27:59another page, you still want it to
  2241. 1:28:01inspect what already exists, reuse the
  2242. 1:28:04design system, search for existing
  2243. 1:28:07components, keep the page responsive,
  2244. 1:28:09avoid unrelated changes, and verify what
  2245. 1:28:12it built.
  2246. 1:28:13You could keep writing all of that
  2247. 1:28:15inside every prompt, or you can teach
  2248. 1:28:18Claude that process once, and then reuse
  2249. 1:28:20it.
  2250. 1:28:21And that's what skills are for.
  2251. 1:28:25A skill is a reusable procedure or piece
  2252. 1:28:28of knowledge that Claude can load when
  2253. 1:28:31it becomes relevant.
  2254. 1:28:33At its simplest, a skill is a folder
  2255. 1:28:35containing a skill.md file.
  2256. 1:28:38Inside of that file, you describe what
  2257. 1:28:41the skill does and how Claude should
  2258. 1:28:43handle that kind of work. You can call a
  2259. 1:28:45skill yourself with a forward slash,
  2260. 1:28:47like build UI.
  2261. 1:28:49Or Claude can use it automatically when
  2262. 1:28:51your request matches what the skill is
  2263. 1:28:54meant for.
  2264. 1:28:55This is different from Claude.md,
  2265. 1:28:57because your Claude or agents.md loads
  2266. 1:29:00into every conversation for this
  2267. 1:29:02project. But a skill loads its full
  2268. 1:29:04instructions only when it's actually
  2269. 1:29:07needed. So a detailed UI workflow
  2270. 1:29:11doesn't take up context while you're
  2271. 1:29:12debugging a database migration. So when
  2272. 1:29:16should you write something into the
  2273. 1:29:17Claude.md, or when should you invoke a
  2274. 1:29:20skill? The answer is simple. Just ask
  2275. 1:29:22yourself, is this a project fact, or is
  2276. 1:29:26it a repeatable process? Use PNPM, use
  2277. 1:29:30Drizzle, reuse the existing design
  2278. 1:29:32system, those are facts, and they belong
  2279. 1:29:35in Claude.md.
  2280. 1:29:37But inspect the implementation, find
  2281. 1:29:40reusable components, build the UI, check
  2282. 1:29:42responsive behavior, run the app,
  2283. 1:29:45verify, type check, summarize, is a
  2284. 1:29:47process. Claude only needs it when doing
  2285. 1:29:50that kind of work.
  2286. 1:29:52That's a skill.
  2287. 1:29:54So project fact goes into Claude.md,
  2288. 1:29:57repeatable process is a skill, and a
  2289. 1:29:59one-time task, well, just ask Claude.
  2290. 1:30:02Anthropic specifically recommends skills
  2291. 1:30:05when you keep repeating the same
  2292. 1:30:06instructions or when something inside
  2293. 1:30:09Cloud MD starts becoming a procedure
  2294. 1:30:11rather than project context. And this is
  2295. 1:30:13something that we go into a lot of
  2296. 1:30:15detail about within the skills module of
  2297. 1:30:18the course.
  2298. 1:30:19Such as how to understand the skills,
  2299. 1:30:21read them, build your own, and when you
  2300. 1:30:24should use MCPs instead of skills as
  2301. 1:30:26well.
  2302. 1:30:27But let me tell you a bit about them
  2303. 1:30:28here as well.
  2304. 1:30:30Project skills live inside of the dot
  2305. 1:30:32cloud folder and then within the skills
  2306. 1:30:35folder.
  2307. 1:30:36So, let me show you how to create a
  2308. 1:30:37skill.
  2309. 1:30:38Head over into dot cloud, create a new
  2310. 1:30:41folder called skills, and then within
  2311. 1:30:43skills create another folder called
  2312. 1:30:46build-ui.
  2313. 1:30:48And then within it, you can also create
  2314. 1:30:50a new file called skill .md just like
  2315. 1:30:54this.
  2316. 1:30:55The directory name becomes the command.
  2317. 1:30:59Build UI. Because this skill is specific
  2318. 1:31:03to our store, keeping it inside of the
  2319. 1:31:05project means you can commit it with the
  2320. 1:31:07code and everyone gets the same
  2321. 1:31:09workflow.
  2322. 1:31:10A skill for all your projects would live
  2323. 1:31:13not under this cloud folder, but under
  2324. 1:31:15the cloud folder of your computer.
  2325. 1:31:18Now, a skill has a YAML formatter and
  2326. 1:31:21markdown instructions. And that looks
  2327. 1:31:23something like this. You start with
  2328. 1:31:25three dashes, then you give it a name
  2329. 1:31:28such as build UI as well as a
  2330. 1:31:31description. And here we can say
  2331. 1:31:33something like build or update
  2332. 1:31:37customer
  2333. 1:31:38facing
  2334. 1:31:40e-commerce UI
  2335. 1:31:42using the existing design system
  2336. 1:31:46components,
  2337. 1:31:47product patterns, and responsive
  2338. 1:31:51conventions.
  2339. 1:31:52And here you also have to tell it when
  2340. 1:31:54should it invoke it. So, we can tell it
  2341. 1:31:56to use it when creating or significantly
  2342. 1:31:59changing pages, sections, or customer
  2343. 1:32:02facing components. Then, you close this
  2344. 1:32:04header with three more dashes, and
  2345. 1:32:07you're ready to write the body of a
  2346. 1:32:08skill.
  2347. 1:32:10In this case, we can say build or update
  2348. 1:32:13the following UI.
  2349. 1:32:14And skills can also accept arguments.
  2350. 1:32:18You use the dollar sign, and then say
  2351. 1:32:20arguments.
  2352. 1:32:21So, we're asking it to build a UI off
  2353. 1:32:24whatever we pass into it. So, we're
  2354. 1:32:26telling it to build a UI off whatever
  2355. 1:32:29they pass here.
  2356. 1:32:30Arguments going to be filled in with
  2357. 1:32:32whatever you type after the command. So,
  2358. 1:32:34the skill carries over the process, and
  2359. 1:32:36you only describe the feature. And then,
  2360. 1:32:38we can give it some steps,
  2361. 1:32:40such as inspect the current
  2362. 1:32:41implementation and related components,
  2363. 1:32:43search for reusable components before
  2364. 1:32:45creating new ones, reuse the existing
  2365. 1:32:47design system, and so on.
  2366. 1:32:51Notice how we're not turning this
  2367. 1:32:52skill.md into a huge manual. Rather, it
  2368. 1:32:55is focused.
  2369. 1:32:57If it eventually needs large references,
  2370. 1:32:59materials, or scripts, those can be
  2371. 1:33:01moved into separate files within the
  2372. 1:33:03build UI folder. And the part that
  2373. 1:33:06matters much more than it looks like is
  2374. 1:33:09the description.
  2375. 1:33:10The description isn't just documentation
  2376. 1:33:12for you.
  2377. 1:33:13It's how Claude decides whether this
  2378. 1:33:16skill is relevant.
  2379. 1:33:18Claude reads the names and descriptions
  2380. 1:33:20of available skills, and matches them
  2381. 1:33:23against your request.
  2382. 1:33:25If you give it a description of useful
  2383. 1:33:28UI workflow, well, that basically tells
  2384. 1:33:31it nothing. But if you specify it like
  2385. 1:33:33this, that tells Claude what the skill
  2386. 1:33:36does and when to use it.
  2387. 1:33:38So, a weak description is going to be
  2388. 1:33:40the main reason that a skill doesn't
  2389. 1:33:42trigger when you expect it to. So, now,
  2390. 1:33:45instead of that same long checklist, we
  2391. 1:33:48can just open up Claude and tell it
  2392. 1:33:51/build
  2393. 1:33:53UI,
  2394. 1:33:54which is going to build or update
  2395. 1:33:55customer-facing e-commerce UI using the
  2396. 1:33:58existing design system components and so
  2397. 1:34:00on. And then we can tell it build a new
  2398. 1:34:04arrivals
  2399. 1:34:05page using the latest
  2400. 1:34:08products
  2401. 1:34:09from the database.
  2402. 1:34:12Keep it consistent with the home page
  2403. 1:34:15product listing and product detail pages
  2404. 1:34:20already in the application.
  2405. 1:34:23Perfect.
  2406. 1:34:24Now that we have the skill, it's much
  2407. 1:34:26easier as we don't have to have such
  2408. 1:34:28detailed and accurate prompts.
  2409. 1:34:31So, let's see how it approaches it. And
  2410. 1:34:33I'm running it with auto mode on. And
  2411. 1:34:36there we go. In a couple of minutes, the
  2412. 1:34:38new arrivals is now live and reachable
  2413. 1:34:41from Chrome. It added a new page, server
  2414. 1:34:44components, breadcrumbs, hairline rule,
  2415. 1:34:47empty states with no new colors,
  2416. 1:34:49classes, or components.
  2417. 1:34:51So, we can explore it on localhost:3000.
  2418. 1:34:54Back in the browser, we can browse our
  2419. 1:34:56existing collections or product pages,
  2420. 1:34:59or you can head over into this new in at
  2421. 1:35:02the top left and see what seems to be a
  2422. 1:35:05category page sorted by the newest
  2423. 1:35:08pieces right here. It did it incredibly
  2424. 1:35:11well, and of course, even from here, you
  2425. 1:35:13can visit a specific product page.
  2426. 1:35:16And if you take a closer look at how it
  2427. 1:35:18did it, Claude simply loaded the skill
  2428. 1:35:21and inspected the existing
  2429. 1:35:22implementation. You can see that right
  2430. 1:35:24here. Skill loaded successfully.
  2431. 1:35:27And then it searched for one pattern,
  2432. 1:35:29read three files, listed one directory,
  2433. 1:35:31and only then did it start with the
  2434. 1:35:33implementation.
  2435. 1:35:35So, the skill follows the workflow, but
  2436. 1:35:38we only described what we are building.
  2437. 1:35:41And it's completely reusable. You can
  2438. 1:35:44also tell it to do something else, such
  2439. 1:35:45as build UI, add a category collection
  2440. 1:35:48page, and let's see how quickly and how
  2441. 1:35:51well does it do that. And just like
  2442. 1:35:54that, again, in about 2 minutes, it
  2443. 1:35:56added a new page.
  2444. 1:35:58So, back in the browser, we can test it
  2445. 1:36:01out by heading over to a specific
  2446. 1:36:03collection, like going to maybe
  2447. 1:36:06sunglasses, and then right here using
  2448. 1:36:08breadcrumbs, you can head over to
  2449. 1:36:10eyewear. And you'll see that we have
  2450. 1:36:12three pieces belonging to eyewear right
  2451. 1:36:14here. You can also browse other things
  2452. 1:36:17such as leather goods, and I can notice
  2453. 1:36:19that we still have to connect it from
  2454. 1:36:21our navigation bar, but right now we can
  2455. 1:36:23navigate over from the collections part.
  2456. 1:36:25So, you can see we have leather, we have
  2457. 1:36:28eyewear, there's jewelry as well. So,
  2458. 1:36:31you can see that now we have full-on
  2459. 1:36:33product categories. And that was pretty
  2460. 1:36:35simple to build, right? This was the
  2461. 1:36:37same process as running the initial
  2462. 1:36:40prompt, just on a different feature.
  2463. 1:36:42And this is where skills become much
  2464. 1:36:44more useful than saving prompts
  2465. 1:36:46somewhere. You're turning the way you
  2466. 1:36:47work into something reusable. And that's
  2467. 1:36:50exactly why I've built the agentic
  2468. 1:36:52engineering workflow I mentioned at the
  2469. 1:36:54start of the video. What you just did
  2470. 1:36:56with the build UI skill is the same idea
  2471. 1:36:59applied to the entire engineering
  2472. 1:37:02workflow. Instead of repeatedly telling
  2473. 1:37:03an AI to inspect the project, decide
  2474. 1:37:06what should be built,
  2475. 1:37:08make the technical decisions, develop
  2476. 1:37:10the features,
  2477. 1:37:12verify them, test them, check them,
  2478. 1:37:14review them, and keep the project
  2479. 1:37:16context updated with sync, each one of
  2480. 1:37:18those becomes a reusable skill. Scope is
  2481. 1:37:22the first one. It figures out what
  2482. 1:37:25should actually be built. Then, there's
  2483. 1:37:27the audit, which studies what already
  2484. 1:37:30exists.
  2485. 1:37:31Architect works through the important
  2486. 1:37:33technical decision. Develop
  2487. 1:37:36implements the feature. Check simply
  2488. 1:37:38verifies or reviews the work.
  2489. 1:37:42Test handles testing. Document updates
  2490. 1:37:45documentation. Sync keeps the project
  2491. 1:37:48context up to date, and debug gives you
  2492. 1:37:51a proper debugging process instead of
  2493. 1:37:53letting it randomly change files until
  2494. 1:37:55something works. The workflow is
  2495. 1:37:57completely free and open source, and
  2496. 1:38:00because it's built on skills, it works
  2497. 1:38:02with Claude Code, Cursor, Codex, or any
  2498. 1:38:04other agent.
  2499. 1:38:06And on top of it, the Agentic
  2500. 1:38:08Engineering course is where I show you
  2501. 1:38:10how to use all of it properly on larger
  2502. 1:38:12applications, legacy codebases, and
  2503. 1:38:15monorepos. Both links are going to be in
  2504. 1:38:17the description in case you want to
  2505. 1:38:19check it out. But to get back to skills
  2506. 1:38:21briefly, I want to tell you that you
  2507. 1:38:23don't always have to manually type
  2508. 1:38:25buildUI or any other skill name. If you
  2509. 1:38:28properly wrote the name of the skill and
  2510. 1:38:31its description,
  2511. 1:38:32running something like add a new
  2512. 1:38:34arrivals page using the current design
  2513. 1:38:36system should be enough because Claude
  2514. 1:38:39can see the skill description, recognize
  2515. 1:38:41the match, and load it automatically.
  2516. 1:38:43And that's one of the major differences
  2517. 1:38:45between skills and older custom {slash}
  2518. 1:38:48commands, user invoked versus model
  2519. 1:38:51invoked. But you don't always want both.
  2520. 1:38:54Imagine you create something like a
  2521. 1:38:56deploy skill or a commit skill.
  2522. 1:38:59Those have real side effects, and you
  2523. 1:39:02probably don't want Claude deciding on
  2524. 1:39:04its own, everything looks ready, I'll
  2525. 1:39:06deploy it.
  2526. 1:39:07So for workflows like that,
  2527. 1:39:09you can head over to that specific
  2528. 1:39:11skill,
  2529. 1:39:12and you can modify its front matter
  2530. 1:39:16with an additional line, disable model
  2531. 1:39:19invocation set to true.
  2532. 1:39:21Now only you can trigger it manually.
  2533. 1:39:24And another reason why skills scale
  2534. 1:39:26better than simply stuffing Claude MD is
  2535. 1:39:29how they load.
  2536. 1:39:31There are three layers.
  2537. 1:39:33First, Claude sees the metadata, which
  2538. 1:39:36is the name and the description. When
  2539. 1:39:38the skill becomes relevant, it loads the
  2540. 1:39:40skill MD file. And if the skill has
  2541. 1:39:43extra references right here in the same
  2542. 1:39:45folder, for example, scripts or
  2543. 1:39:47examples, we can load those only when
  2544. 1:39:50necessary. So, the main skill MD doesn't
  2545. 1:39:53need the entire design system inside it.
  2546. 1:39:55It can point Claude to something like
  2547. 1:39:57references design system MD whenever
  2548. 1:40:00deeper guidance is needed. Anthropic
  2549. 1:40:02calls this progressive disclosure. If
  2550. 1:40:05you take a look at the skills of the
  2551. 1:40:06agentic engineering workflow, and
  2552. 1:40:08specifically the scope or architect
  2553. 1:40:10skills, you can see that alongside the
  2554. 1:40:13skill MD, there's so much more stuff
  2555. 1:40:15right here. Such as the scope template
  2556. 1:40:18that it can read whenever it needs to.
  2557. 1:40:20The modes, such as the brownfield
  2558. 1:40:23project, greenfield project, plan,
  2559. 1:40:26replan, and more.
  2560. 1:40:27Three different development approaches,
  2561. 1:40:29facade, journey, skateboard, and tracer
  2562. 1:40:31bullet, which are actual software
  2563. 1:40:33development workflows to follow when
  2564. 1:40:35building applications, as well as the
  2565. 1:40:37YAML file right here.
  2566. 1:40:40All of those are part of a larger skills
  2567. 1:40:43setup. And in the course, we go a bit
  2568. 1:40:45deeper into how to build your own skill.
  2569. 1:40:48Oh, and another pro tip is that you
  2570. 1:40:50don't have to write every skill MD by
  2571. 1:40:51hand. Anthropic has something called a
  2572. 1:40:54skill creator workflow that builds and
  2573. 1:40:57improves skills through conversation.
  2574. 1:40:59And it can even run evaluation cases
  2575. 1:41:01with and without the skill to check
  2576. 1:41:03whether it actually improves Claude's
  2577. 1:41:05behavior. Because a skill that sounds
  2578. 1:41:07good isn't necessarily a skill that
  2579. 1:41:10works. So, test it. You can run it
  2580. 1:41:12easily by running the skill creator
  2581. 1:41:14skill and tell it what skill you want to
  2582. 1:41:16create. Another pro tip is to not turn
  2583. 1:41:19this Claude skills folder into a mess.
  2584. 1:41:23Every skill adds metadata that Claude
  2585. 1:41:25has to consider.
  2586. 1:41:2710 useful skills are fine, but 100
  2587. 1:41:29random ones aren't. There's also a
  2588. 1:41:32custom skill called skill doctor, which
  2589. 1:41:35can show you which loaded skills are
  2590. 1:41:37unused and costing context. That way,
  2591. 1:41:41you can just delete them.
  2592. 1:41:43And also, be careful with the skills you
  2593. 1:41:45download. They can contain scripts,
  2594. 1:41:48command executions, and tool access. So,
  2595. 1:41:51read the skill.md and any scripts before
  2596. 1:41:53installing. Whenever you do try to
  2597. 1:41:55install them, you'll also get some
  2598. 1:41:57information on whether they might
  2599. 1:41:58include something sketchy. If we install
  2600. 1:42:01my own skills right here by exiting the
  2601. 1:42:05Claude and MPX skills latest js mastery
  2602. 1:42:08pro skills, you'll need to install the
  2603. 1:42:10skills package. Select which skills to
  2604. 1:42:13install.
  2605. 1:42:14You can do them either on a project or a
  2606. 1:42:16global basis. And you can see that here
  2607. 1:42:19you'll see that most of them are safe.
  2608. 1:42:21And for some reason, if something got
  2609. 1:42:22changed in the meantime, maybe some are
  2610. 1:42:24going to be medium or high risk or some
  2611. 1:42:27are going to be like, "Please don't
  2612. 1:42:28install them." But I can assure you that
  2613. 1:42:31these skills are more than safe. And
  2614. 1:42:33yeah, the last pro tip would be to try
  2615. 1:42:36not to design the perfect skill on day
  2616. 1:42:39one.
  2617. 1:42:40Rather, use it. Watch where Claude still
  2618. 1:42:43makes mistake and then fix that skill.
  2619. 1:42:46Add some kind of a missing rule or
  2620. 1:42:48sharpen the verification step. Fix a
  2621. 1:42:50description that triggers it whenever
  2622. 1:42:52you need it and not at the wrong times.
  2623. 1:42:54Skills improve from the actual usage.
  2624. 1:42:58So, by this point, you've already moved
  2625. 1:43:00beyond giving Claude some random
  2626. 1:43:02individual prompts.
  2627. 1:43:04Your Claude MD now keeps the rules that
  2628. 1:43:07should always be available. Permissions
  2629. 1:43:09control what Claude can do. Plan mode
  2630. 1:43:12reviews the approach before the
  2631. 1:43:13implementations. And skills can give you
  2632. 1:43:16reusable workflows that load only when
  2633. 1:43:19needed.
  2634. 1:43:20The next step is what happens when one
  2635. 1:43:22Claude session doesn't need to do every
  2636. 1:43:25part of the work itself.
  2637. 1:43:27So, let's work on that next.
  2638. 1:43:31At this point, you've learned quite a
  2639. 1:43:33few Cloud Code features individually.
  2640. 1:43:36Cloud MD for project context,
  2641. 1:43:38permissions for control, plan mode for
  2642. 1:43:41expensive decisions, and your own skills
  2643. 1:43:44for repeatable processes.
  2644. 1:43:46And our storefront looks like a real
  2645. 1:43:49store now.
  2646. 1:43:50But you still can't actually buy
  2647. 1:43:53anything.
  2648. 1:43:54We're missing authentication, a cart,
  2649. 1:43:57stock enforcement, checkout orders, and
  2650. 1:44:00the customer account. But here's the
  2651. 1:44:02thing.
  2652. 1:44:03Building all of that is the exact same
  2653. 1:44:06loop you've already learned over and
  2654. 1:44:09over. Describe the feature,
  2655. 1:44:12plan when the decision is expensive, and
  2656. 1:44:15let Cloud build, review, and verify it.
  2657. 1:44:18So, I'm not going to build it at you.
  2658. 1:44:21This is your assessment.
  2659. 1:44:24You're going to ship the rest of the
  2660. 1:44:25store yourself, and I'll give you
  2661. 1:44:27everything you need. Every prompt in
  2662. 1:44:30order in the free resources linked
  2663. 1:44:32below.
  2664. 1:44:33But before you start, let me show you
  2665. 1:44:35three things that make this assessment
  2666. 1:44:38much easier. Because you don't have to
  2667. 1:44:40do all of it with plain prompts. First,
  2668. 1:44:43the UI. You already built the build UI
  2669. 1:44:47skill in the last lesson.
  2670. 1:44:49The cart page, the account overview,
  2671. 1:44:51order history, those are exactly what
  2672. 1:44:54the skill is for.
  2673. 1:44:55So, you can just use the build UI skill
  2674. 1:44:58and tell it to build the cart page, or
  2675. 1:45:03build the account overview.
  2676. 1:45:05It is the same process, just a different
  2677. 1:45:08feature. And that's the whole point of
  2678. 1:45:10encoding your workflow into a skill.
  2679. 1:45:12This assessment will reuse it. But
  2680. 1:45:15second, you're going to have to work on
  2681. 1:45:17authentication. You could prompt it from
  2682. 1:45:20scratch,
  2683. 1:45:21but remember how skills work.
  2684. 1:45:24They don't have to come from you.
  2685. 1:45:26Libraries, such as BetterAuth, can
  2686. 1:45:29publish skills that teach agents how
  2687. 1:45:31their APIs and workflows are supposed to
  2688. 1:45:34be used.
  2689. 1:45:36So, BetterAuth does exactly that, so we
  2690. 1:45:38can install their skills.
  2691. 1:45:40Back within our application, you can
  2692. 1:45:42open up a new terminal window and run
  2693. 1:45:44MPX skills add BetterAuth skills, like
  2694. 1:45:48this.
  2695. 1:45:49It'll then ask you which skills you want
  2696. 1:45:51to install. You can install some
  2697. 1:45:52additional ones or just the core auth
  2698. 1:45:55skills, which I'll select. I'll select
  2699. 1:45:57it for my Claude code.
  2700. 1:46:00Press enter a few more times and they're
  2701. 1:46:02going to get installed immediately.
  2702. 1:46:04That'll install BetterAuth's official
  2703. 1:46:06skill pack. And you can even see that
  2704. 1:46:08right here, how we have our own skill,
  2705. 1:46:11we now also have this agents folder,
  2706. 1:46:13within it we have skills, and then there
  2707. 1:46:16are two skills. One is called create
  2708. 1:46:18auth and the other one is called
  2709. 1:46:20BetterAuth best practices.
  2710. 1:46:22Now that you know how to create your own
  2711. 1:46:23skill, you also should understand how
  2712. 1:46:26some other people or companies can
  2713. 1:46:29create their own skills maintained by
  2714. 1:46:32the developers who build a library and
  2715. 1:46:34instead of hoping Claude remembers
  2716. 1:46:36exactly how the latest version works,
  2717. 1:46:38the maintainers give your agent
  2718. 1:46:41instructions directly. And the habit
  2719. 1:46:43from the last lesson still applies. A
  2720. 1:46:46skill can contain instructions, scripts
  2721. 1:46:49and tools. These come from BetterAuth
  2722. 1:46:51itself, but always look at what you just
  2723. 1:46:54gave your agent. For example, make sure
  2724. 1:46:56that the skill will actually get
  2725. 1:46:58executed based on your prompt. Oh, and
  2726. 1:47:00one more tip when you do the auth part
  2727. 1:47:02of the assessment. Run it in plan mode
  2728. 1:47:05first. Authentication touches the
  2729. 1:47:07database, sessions, protected routes and
  2730. 1:47:10customer data, which is exactly what
  2731. 1:47:12kind of change the plan mode is for.
  2732. 1:47:14And I'll leave the exact planning prompt
  2733. 1:47:16in the resources down below. On top of
  2734. 1:47:18the skills that we have built and the
  2735. 1:47:21skills that you going to install,
  2736. 1:47:22there's also a third thing called
  2737. 1:47:25plugins.
  2738. 1:47:27In the same way that specific tools can
  2739. 1:47:29create their own skills, some more
  2740. 1:47:31well-established tools can publish
  2741. 1:47:33official Claude plugins.
  2742. 1:47:36The Stripe plugin, for example, which
  2743. 1:47:38we'll have to use for checkout, allows
  2744. 1:47:40Claude to connect to Stripe's MCP
  2745. 1:47:42server, enabling AI-assisted payment
  2746. 1:47:45integration development.
  2747. 1:47:46As a skill, it provides everything that
  2748. 1:47:48a skill does, such as best practices,
  2749. 1:47:51guidance for implementing checkout
  2750. 1:47:53flows, subscriptions, and more, as well
  2751. 1:47:55as more on top of it, such as helping
  2752. 1:47:57you avoid deprecated APIs and follow
  2753. 1:48:00Stripe's recommended patterns.
  2754. 1:48:02So, you can very easily install it by
  2755. 1:48:04copying this installation command.
  2756. 1:48:07You can do that in the terminal by
  2757. 1:48:09running Claude plugin install
  2758. 1:48:11stripe@claude-plugins-official.
  2759. 1:48:14And just press enter. It'll ask you
  2760. 1:48:16whether you want to install the plugin,
  2761. 1:48:18and very soon it'll be installed.
  2762. 1:48:21So, now if you run Claude,
  2763. 1:48:24and you run {forward slash} plugins,
  2764. 1:48:27you'll be able to see which plugins you
  2765. 1:48:29might have installed before. I have a
  2766. 1:48:31couple, but in this case, we are looking
  2767. 1:48:33for the Stripe plugin, which might
  2768. 1:48:36already be under installed. There we go.
  2769. 1:48:40You just need to press enter to
  2770. 1:48:41authenticated from Stripe. So, go ahead
  2771. 1:48:44and press authenticate, and it'll be
  2772. 1:48:46opened in a new browser window, where
  2773. 1:48:48you'll have to sign into your Stripe
  2774. 1:48:50account. Then, you'll have to enable
  2775. 1:48:53your MCP.
  2776. 1:48:54I'll do it for the test environment and
  2777. 1:48:56give it all the necessary permissions
  2778. 1:48:58and authorize.
  2779. 1:49:00And that's it. You can now close this
  2780. 1:49:02tab and return to Claude Code.
  2781. 1:49:05And just like that, you have
  2782. 1:49:06successfully authenticated your plugin.
  2783. 1:49:09So, now you know not only how to create
  2784. 1:49:11your own skills, but install other
  2785. 1:49:13people's skills, as well as plugins.
  2786. 1:49:16There's one small distinction between
  2787. 1:49:18the two. You can think of a skill as a
  2788. 1:49:20one reusable process, whereas a plugin
  2789. 1:49:23is a package that can include skills as
  2790. 1:49:26well as other Cloud Code capabilities,
  2791. 1:49:29such as MCPs.
  2792. 1:49:31And you can also browse what's installed
  2793. 1:49:33with the {forward slash} plugin command.
  2794. 1:49:36And same rule as always applies, don't
  2795. 1:49:38install random plugins. They can contain
  2796. 1:49:42much more than markdown, so trust where
  2797. 1:49:44they come from. So now you have
  2798. 1:49:47everything you need. Your BuildUI skill
  2799. 1:49:49for the pages, Better Auth community
  2800. 1:49:51skills for authentication, and Stripe's
  2801. 1:49:53official plugin for the checkout.
  2802. 1:49:56The full assessment is in the free
  2803. 1:49:58resource linked below.
  2804. 1:50:00It contains a couple of prompts in order
  2805. 1:50:02from authentication all the way to the
  2806. 1:50:04customer accounts. So build it, break
  2807. 1:50:07it, fix it, use the plan mode where the
  2808. 1:50:09decision is expensive, and skip it where
  2809. 1:50:12it isn't.
  2810. 1:50:13And that's where everything from this
  2811. 1:50:14course actually becomes yours.
  2812. 1:50:17If you're just following along, you're
  2813. 1:50:19not learning as much.
  2814. 1:50:21But now that you've been watching this
  2815. 1:50:22video for more than an hour, it's time
  2816. 1:50:24for you to actually give it a shot.
  2817. 1:50:27And when you're done, tell me in the
  2818. 1:50:29comments how it went. I do read all of
  2819. 1:50:31the comments.
  2820. 1:50:33Pause this video, do it, and then let's
  2821. 1:50:35continue together. So, how did it go?
  2822. 1:50:38After I ran a couple of these prompts,
  2823. 1:50:41the last step was to create and hook up
  2824. 1:50:44my Stripe account. Thankfully, that was
  2825. 1:50:47easy thanks to the Stripe package and
  2826. 1:50:49the CLI. So I was more or less able to
  2827. 1:50:52do it directly to the terminal, but I
  2828. 1:50:54simply got the Stripe secret key and
  2829. 1:50:56added it to the ENVs, so Cloud doesn't
  2830. 1:50:58have access to it. With that in mind,
  2831. 1:51:01our application now not only looks good,
  2832. 1:51:04but has a real database and a real
  2833. 1:51:07checkout where we can actually buy
  2834. 1:51:09stuff.
  2835. 1:51:10So let me add this to a bag. You can see
  2836. 1:51:13that now we can sign in. So, this is a
  2837. 1:51:15beautiful looking sign in page, which
  2838. 1:51:17looks exactly as I would expect it from
  2839. 1:51:20a luxury storefront. So, let me go ahead
  2840. 1:51:23and enter my contact information. In
  2841. 1:51:25this case, of course, we can't sign in
  2842. 1:51:27because we never created an account, but
  2843. 1:51:29let's go ahead and create one.
  2844. 1:51:32I'll call myself JS Mastery.
  2845. 1:51:35And I'll create a new account.
  2846. 1:51:39There we go. Looks like we are now
  2847. 1:51:41signed in successfully. So, we can go
  2848. 1:51:43ahead and add some items to the cart.
  2849. 1:51:46Let's go ahead and add this uh Bordeaux
  2850. 1:51:48croc embossed flap bag, close to 3,000
  2851. 1:51:52bucks.
  2852. 1:51:53As well as let's try to add something
  2853. 1:51:56else, maybe these sunglasses right here
  2854. 1:52:00or this card holder. Let's go with Oh,
  2855. 1:52:02it's sold out. This is nice. So, the
  2856. 1:52:04sold out functionality works as well.
  2857. 1:52:07And you can see that there's email me
  2858. 1:52:09when it returns functionality, which we
  2859. 1:52:10can implement later on as well.
  2860. 1:52:13Let's go with this backpack.
  2861. 1:52:15Okay, we have added those two to the bag
  2862. 1:52:18and you can now see how that looks like.
  2863. 1:52:20Only to modify the design slightly, so
  2864. 1:52:22it looks a bit better, but let's try to
  2865. 1:52:25proceed to the checkout. This actually
  2866. 1:52:27opens up a complete Stripe checkout in
  2867. 1:52:31sandbox mode. And oh my god, I would
  2868. 1:52:34never pay close to 5,000 bucks for a bag
  2869. 1:52:38and a backpack. But thankfully, I can
  2870. 1:52:40use my test card right here by just
  2871. 1:52:42pressing the letters four and two one
  2872. 1:52:45after another. And with that, we can now
  2873. 1:52:47pay.
  2874. 1:52:48In about a minute, it looks like it's
  2875. 1:52:50exceeded and we can see a thank you
  2876. 1:52:52page.
  2877. 1:52:53Of course, the next natural steps would
  2878. 1:52:55be to take a screenshot of this page
  2879. 1:52:57right here that says thank you, as well
  2880. 1:53:00as of the other pages that we have seen,
  2881. 1:53:02which don't look as good and then fix
  2882. 1:53:05the UI of them. But that will be super
  2883. 1:53:08simple. Like, I can remain on this page
  2884. 1:53:10right now, head over to the code, and
  2885. 1:53:12then simply drag and drop the photo
  2886. 1:53:15while holding the shift key,
  2887. 1:53:17and then tell it
  2888. 1:53:18the design seems off. Improve the UI of
  2889. 1:53:25the thank you page.
  2890. 1:53:28And we can say use front-end skills.
  2891. 1:53:32This should take about a minute, and
  2892. 1:53:33then without reloading, we should be
  2893. 1:53:36able to see this page get to its proper
  2894. 1:53:38look to match the rest of this beautiful
  2895. 1:53:40design. And it looks like it found it
  2896. 1:53:43pretty quickly. It'll load the design
  2897. 1:53:44skill before reworking the page and fix
  2898. 1:53:47it. And in about a minute, this is much
  2899. 1:53:51much better.
  2900. 1:53:52Or should I say much worse because now I
  2901. 1:53:54can more clearly see this huge amount
  2902. 1:53:57that was spent, well, thankfully on my
  2903. 1:53:59testing account. But, yeah, as you can
  2904. 1:54:01see, with the right tools and the right
  2905. 1:54:03process, I didn't even have to tell you
  2906. 1:54:05how to fix this because I've taught you
  2907. 1:54:07the process of developing on your own.
  2908. 1:54:10And believe it or not, this is it. We
  2909. 1:54:13have successfully implemented the full
  2910. 1:54:15functionality for logging in, for adding
  2911. 1:54:17the items of the cart, as well as
  2912. 1:54:20purchasing the items for our account
  2913. 1:54:23through our Atelier store. Wonderful.
  2914. 1:54:26And these items are also getting
  2915. 1:54:29updated, so you can see since we added
  2916. 1:54:31this backpack, maybe this one has more
  2917. 1:54:33items in stock, but if we take a look at
  2918. 1:54:35this one, this one only has three left.
  2919. 1:54:39So, yeah, the store is officially done.
  2920. 1:54:42You can go ahead and play with the
  2921. 1:54:43design a bit more, fix a couple of those
  2922. 1:54:45pages that didn't look as good, or
  2923. 1:54:47modify this hero section, or center the
  2924. 1:54:50items in the navigation bar. At least
  2925. 1:54:52that's something that I would do if I
  2926. 1:54:53was continuing to develop this
  2927. 1:54:55application further. But, now that we
  2928. 1:54:57have a fully functional e-commerce
  2929. 1:54:59store, somebody still has to run it.
  2930. 1:55:02There's no place to create products, to
  2931. 1:55:05update the inventory, or manage orders.
  2932. 1:55:08We need an admin side. So, in this
  2933. 1:55:11video, I'll teach you how to do that,
  2934. 1:55:13too. And keep in mind that that admin
  2935. 1:55:15side touches almost everything.
  2936. 1:55:18It touches the database, which we
  2937. 1:55:20haven't opened in some time. So, now
  2938. 1:55:22would be a good time if you head over
  2939. 1:55:24into tables, you can see the exact
  2940. 1:55:27number of items that we have for each
  2941. 1:55:30specific product. You can see that these
  2942. 1:55:33two are low in stock, and for now we can
  2943. 1:55:37update the stock manually like this.
  2944. 1:55:39But, we don't really want to do that. We
  2945. 1:55:41want to do that through an admin system
  2946. 1:55:43that touches the database,
  2947. 1:55:45authentication, products, inventory,
  2948. 1:55:47orders, and all of that. Now, Claude
  2949. 1:55:49could investigate all of that inside of
  2950. 1:55:52our main conversation, but it would fill
  2951. 1:55:54the same context that we need to use for
  2952. 1:55:57building. And that's where the sub
  2953. 1:55:59agents come in. So, let me teach you a
  2954. 1:56:01bit about them in the next lesson.
  2955. 1:56:05The customer side of our store is now a
  2956. 1:56:09pretty good place. A customer can browse
  2957. 1:56:12products, search, create an account, add
  2958. 1:56:14products to cart, check out, place an
  2959. 1:56:16order, or see their order history.
  2960. 1:56:19But, somebody still has to actually run
  2961. 1:56:23the store.
  2962. 1:56:24We need an admin side where someone can
  2963. 1:56:27create and edit products, manage
  2964. 1:56:29categories, update the inventory, see
  2965. 1:56:32the orders, or update the order status.
  2966. 1:56:35And this is where our application has
  2967. 1:56:38finally become large enough that another
  2968. 1:56:40Claude code feature becomes genuinely
  2969. 1:56:43useful.
  2970. 1:56:44Because before Claude builds the admin
  2971. 1:56:46side, it needs to understand quite a few
  2972. 1:56:49different areas of the application.
  2973. 1:56:51Authentication, products, database
  2974. 1:56:54schema, inventory, orders, existing UI
  2975. 1:56:57patterns.
  2976. 1:56:58Claude could research all of that inside
  2977. 1:57:01of the main conversation. But then all
  2978. 1:57:03of those file reads, searches, and
  2979. 1:57:05intermediate findings would fill the
  2980. 1:57:07same context we're about to use to
  2981. 1:57:10actually build the feature. And that's
  2982. 1:57:13where the sub-agents come in.
  2983. 1:57:15A sub-agent is another Claude agent that
  2984. 1:57:18receives a focused task and works on it
  2985. 1:57:22inside of its own context.
  2986. 1:57:25The main Claude delegates the task, the
  2987. 1:57:28sub-agent investigates it, and then
  2988. 1:57:31reports the important result back.
  2989. 1:57:34So, instead of your main conversation
  2990. 1:57:36carrying every file and every search the
  2991. 1:57:39sub-agent needed, you mainly get back
  2992. 1:57:42the useful findings.
  2993. 1:57:44That's the real value. Sub-agents give
  2994. 1:57:47you context isolation.
  2995. 1:57:49They're not magically smarter versions
  2996. 1:57:51of Claude. They're only useful because
  2997. 1:57:54some work can happen separately. And
  2998. 1:57:57don't think of them as AI employees
  2999. 1:58:00because this is where sub-agents
  3000. 1:58:02sometimes get over complicated.
  3001. 1:58:04People create things like senior staff
  3002. 1:58:07back-end engineer or elite security
  3003. 1:58:10architect, world-class React expert. But
  3004. 1:58:13Claude doesn't suddenly gain new
  3005. 1:58:16knowledge because you gave the context
  3006. 1:58:17window a fancy job title.
  3007. 1:58:20The better question is, what work can
  3008. 1:58:23happen separately that my main
  3009. 1:58:25conversation doesn't need to carry? For
  3010. 1:58:28our admin application, that's pretty
  3011. 1:58:30obvious. Before implementing anything,
  3012. 1:58:33we need several independent
  3013. 1:58:35investigations. So, let's delegate them.
  3014. 1:58:39Now, tell the main Claude something like
  3015. 1:58:42this.
  3016. 1:58:43Before building the admin side of our
  3017. 1:58:45project, investigate the existing
  3018. 1:58:48application using separate focused
  3019. 1:58:51sub-agents.
  3020. 1:58:52Have independently inspect the products,
  3021. 1:58:55categories, and the current Drizzle data
  3022. 1:58:57model, stock and inventory behavior,
  3023. 1:59:01authentication and safest minimal way to
  3024. 1:59:03add admin access, orders and the current
  3025. 1:59:06order life cycle, existing UI patterns
  3026. 1:59:09so we can reuse.
  3027. 1:59:10Each subagent should return the current
  3028. 1:59:12behavior, relevant files, important
  3029. 1:59:15constraints, and a recommended approach.
  3030. 1:59:18Do not implement anything yet. Combine
  3031. 1:59:21their findings into one concise summary
  3032. 1:59:23when they're done. Run it, and now watch
  3033. 1:59:26Claude do its work. It'll dispatch five
  3034. 1:59:29focused investigators in parallel.
  3035. 1:59:32This is a good example of a parallel fan
  3036. 1:59:35out. None of these agents need an answer
  3037. 1:59:38from another agent before beginning
  3038. 1:59:40their investigation.
  3039. 1:59:42Rather, they can independently explore
  3040. 1:59:44the parts of the code base and then
  3041. 1:59:46report back.
  3042. 1:59:48One is investigating the data model.
  3043. 1:59:51Another is investigating the stock
  3044. 1:59:52behavior. And another investigating off
  3045. 1:59:56and admin access. And another
  3046. 1:59:58investigating order life cycle. And the
  3047. 2:00:01last one is investigating the UI
  3048. 2:00:05patterns.
  3049. 2:00:06The main model is not doing anything. It
  3050. 2:00:09is waiting for all the findings to come
  3051. 2:00:11back, and then it'll combine their
  3052. 2:00:13findings into one summary, and then you
  3053. 2:00:15can do something with it. A beautiful
  3054. 2:00:17example of a parallel fan out. So, let's
  3055. 2:00:21give it some time to run. You can see
  3056. 2:00:23for how long each one of these has been
  3057. 2:00:25running, and how many tokens is it
  3058. 2:00:27spending.
  3059. 2:00:28Even though it might seem like it's a
  3060. 2:00:30lot of tokens, you would spend more
  3061. 2:00:32tokens and more time if you just let one
  3062. 2:00:35agent do the thing. This way, the work
  3063. 2:00:37is being done five times as fast. One
  3064. 2:00:41already finished after a minute and 20
  3065. 2:00:43seconds. And we're waiting for the four
  3066. 2:00:46other ones to finish as well.
  3067. 2:00:48You can switch to another model to see
  3068. 2:00:50what it is doing at any time
  3069. 2:00:53or simply get back to the main.
  3070. 2:00:55Four in, one to go. The UI patterns
  3071. 2:00:58agent is still working.
  3072. 2:01:00And that one reported, too. All five
  3073. 2:01:02investigations are complete and here are
  3074. 2:01:05the combined findings. We can see
  3075. 2:01:07everything we need to know about our
  3076. 2:01:08data model,
  3077. 2:01:09about the stock, how there are four
  3078. 2:01:11states,
  3079. 2:01:13the constraints about it as well, the
  3080. 2:01:15auth and the admin access, the
  3081. 2:01:17recommendation on how to approach
  3082. 2:01:19authentication for the admin panel, and
  3083. 2:01:21then there's orders, how we can keep
  3084. 2:01:23track of them or increase the number of
  3085. 2:01:26items, and then there are UI patterns
  3086. 2:01:29that follow this editorial luxury system
  3087. 2:01:32entirely stored in globals.css.
  3088. 2:01:35There are some cross-cutting themes and
  3089. 2:01:37an important decision to consider before
  3090. 2:01:39proceeding. That's it.
  3091. 2:01:42This took 3 minutes exactly,
  3092. 2:01:44but it did more than 15 minutes at work.
  3093. 2:01:47So, why didn't we just let the main
  3094. 2:01:49Claude read everything? Just imagine the
  3095. 2:01:51product investigation reads 10 files,
  3096. 2:01:53auth 3 reads another eight, and orders
  3097. 2:01:56reads another 12, and then UI
  3098. 2:01:58exploration reads another 10.
  3099. 2:02:01The main Claude may only need a few
  3100. 2:02:03important conclusions from each
  3101. 2:02:05investigation before it can build a
  3102. 2:02:07feature.
  3103. 2:02:08Sub agents let all that exploration
  3104. 2:02:10happen somewhere else.
  3105. 2:02:13The main conversation gets the useful
  3106. 2:02:15result without carrying the entire
  3107. 2:02:17journey.
  3108. 2:02:18And that's the whole point. And you may
  3109. 2:02:21have already seen Claude delegate work
  3110. 2:02:23automatically. I mean, Claude code
  3111. 2:02:26includes built-in agents for different
  3112. 2:02:28kinds of jobs. For example, explore,
  3113. 2:02:31plan, or general-purpose. Explore is
  3114. 2:02:34useful for read-only code-based
  3115. 2:02:36investigation, plan helps with research
  3116. 2:02:39during planning, and general-purpose can
  3117. 2:02:41handle, well, as it says,
  3118. 2:02:43general-purpose tasks.
  3119. 2:02:45But, you don't always need to wait for
  3120. 2:02:48Claude to decide.
  3121. 2:02:50You can simply say, "Use an explore
  3122. 2:02:53sub-agent to inspect how admin
  3123. 2:02:55authorization should fit into the
  3124. 2:02:58current better auth implementation."
  3125. 2:03:00Or something like, "Delegate the order
  3126. 2:03:03life cycle investigation to a separate
  3127. 2:03:06sub-agent and return the important
  3128. 2:03:08findings." Underneath this, the current
  3129. 2:03:10Claude code tool is called agent. You
  3130. 2:03:13usually don't need to call the internal
  3131. 2:03:15tool yourself. You can just tell Claude
  3132. 2:03:17what should be delegated and let it
  3133. 2:03:19handle the mechanics. So, once the
  3134. 2:03:21research comes back, don't immediately
  3135. 2:03:23say, "Build an admin dashboard."
  3136. 2:03:26First, decide what this first admin
  3137. 2:03:29version actually needs.
  3138. 2:03:31For our store, keep it focused. We need
  3139. 2:03:34admin-only access,
  3140. 2:03:36basic dashboard overview,
  3141. 2:03:38product, category, and order management,
  3142. 2:03:41as well as inventory updates.
  3143. 2:03:43We don't need multiple admin permission
  3144. 2:03:46levels,
  3145. 2:03:47warehouse management, advanced
  3146. 2:03:49analytics, staff invitations, refunds,
  3147. 2:03:52or complicated fulfillment systems.
  3148. 2:03:54At least not yet. Now, even without our
  3149. 2:03:56admin panel, but just with the full
  3150. 2:03:59logic of the databases, authentication,
  3151. 2:04:01and more, our application has changed
  3152. 2:04:03massively since we ran that first deep
  3153. 2:04:06scan. Our application now holds
  3154. 2:04:08authentication, sessions, customer data,
  3155. 2:04:12payment logic, orders, and very soon an
  3156. 2:04:15entire admin side with its own
  3157. 2:04:17authorization. So, before we begin
  3158. 2:04:20working on the admin platform of the
  3159. 2:04:22application, we want to commit and push
  3160. 2:04:24everything that we've done so far,
  3161. 2:04:26because there's a lot of work that was
  3162. 2:04:27done. So, I'll tell it, "Commit and push
  3163. 2:04:30all the work done so far." And as soon
  3164. 2:04:33as the changes are in, we can run the
  3165. 2:04:35second Code Rabbit AI deep scan. Let's
  3166. 2:04:39let it look across of it all to see just
  3167. 2:04:41how well have you done your assessment
  3168. 2:04:43or how well Claude has developed it.
  3169. 2:04:46You can also connect Slack to be updated
  3170. 2:04:48when the deep scan is done or you can
  3171. 2:04:50just head over here where you can see
  3172. 2:04:52them estimating and then running. The
  3173. 2:04:54deep scan report will likely be
  3174. 2:04:56different for you than what it is for
  3175. 2:04:58me. But thankfully, the process of
  3176. 2:05:00resolving some of these vulnerabilities
  3177. 2:05:02is the same as what I've shown you
  3178. 2:05:04before. So, feel free to take a coffee
  3179. 2:05:06until the deep scan is back, resolve the
  3180. 2:05:08vulnerabilities which you believe need
  3181. 2:05:10fixing, and then let's continue.
  3182. 2:05:13And here's the thing, from this point
  3183. 2:05:15on, building the admin side is nothing
  3184. 2:05:18you haven't done before. You'd take all
  3185. 2:05:21of these sub agent findings into plan
  3186. 2:05:23mode and plan the admin experience.
  3187. 2:05:27You'd read that plan carefully,
  3188. 2:05:29especially around one thing,
  3189. 2:05:31authorization has to live on the server
  3190. 2:05:34because hiding the admin link isn't
  3191. 2:05:36authorization. And then a normal
  3192. 2:05:38customer should never be able to open an
  3193. 2:05:40admin URL or call an admin action
  3194. 2:05:43directly. But that's exactly the kind of
  3195. 2:05:45decision that you catch in the plan, not
  3196. 2:05:48after the code is written.
  3197. 2:05:50And then, you'd build it feature by
  3198. 2:05:52feature. Admin access first, then
  3199. 2:05:55product management, then inventory, and
  3200. 2:05:57then orders.
  3201. 2:05:59The same loop you've used throughout the
  3202. 2:06:01rest of the course, describe the
  3203. 2:06:03feature, plan when the decision is
  3204. 2:06:05expensive, let Claude build, review, and
  3205. 2:06:08verify. So, the admin side is part two
  3206. 2:06:11of your assessment. Every prompt in
  3207. 2:06:14order is going to be in the free
  3208. 2:06:16resource down below in case you want to
  3209. 2:06:17follow along, but go ahead and give it a
  3210. 2:06:20shot. Try to build it yourself or take a
  3211. 2:06:23look at a couple of hints in that
  3212. 2:06:24document that I've shared. So, pause the
  3213. 2:06:26video and go ahead and do it right now.
  3214. 2:06:29And let me know in the comments how it
  3215. 2:06:30went. Were you able to successfully add
  3216. 2:06:32the admin side to this luxury and overly
  3217. 2:06:36expensive e-commerce store?
  3218. 2:06:39Hopefully, the answer is yes. But even
  3219. 2:06:41if you've built it properly, check
  3220. 2:06:44whether the Claude MD or agents in the
  3221. 2:06:46file that you had from the beginning
  3222. 2:06:48properly describes the application that
  3223. 2:06:50you have right now,
  3224. 2:06:51not the one from five lessons ago.
  3225. 2:06:53Because if that is the case, every
  3226. 2:06:56future Claude session will start with
  3227. 2:06:58stale information that has no idea about
  3228. 2:07:01the admin interface or some of the
  3229. 2:07:03features you developed within it. So,
  3230. 2:07:05update it either manually or through the
  3231. 2:07:08conversation with Claude to analyze the
  3232. 2:07:10code base and update the necessary parts
  3233. 2:07:13and then review it. Or you can use a
  3234. 2:07:15skill that I built specifically for that
  3235. 2:07:17purpose.
  3236. 2:07:18In this case, the skill is part of the
  3237. 2:07:21agentic engineering workflow and it is
  3238. 2:07:24the sync skill.
  3239. 2:07:25You can check it out right here.
  3240. 2:07:27Its goal is to run it after a specific
  3241. 2:07:30feature or an application is complete to
  3242. 2:07:33keep the durable knowledge current.
  3243. 2:07:35Simply put, it keeps your project
  3244. 2:07:37context in sync with the code base by
  3245. 2:07:39checking your latest Git commits,
  3246. 2:07:41updates the relevant parts of Claude and
  3247. 2:07:44agents in the files, and flags anything
  3248. 2:07:46that no longer matches how the project
  3249. 2:07:48actually works.
  3250. 2:07:50And you can use sync completely on your
  3251. 2:07:51own. You don't need the entire workflow
  3252. 2:07:54as it's free and open source. So, maybe
  3253. 2:07:56this is the right chance to give it a
  3254. 2:07:57shot if you haven't already. But now,
  3255. 2:08:00just take a look at how your usage of
  3256. 2:08:02Claude code grew as you kept using the
  3257. 2:08:05app. You started this course with Claude
  3258. 2:08:07in an empty folder. Then, you added the
  3259. 2:08:10permissions so you controlled what it
  3260. 2:08:11could do. You used plan mode when
  3261. 2:08:14decisions became expensive.
  3262. 2:08:16You also used a couple of skills, one of
  3263. 2:08:18which you created yourself, as well as
  3264. 2:08:21external skills and plugins when you
  3265. 2:08:23needed them, when libraries themselves
  3266. 2:08:25provided the guidance.
  3267. 2:08:27And you also used sub agents. When the
  3268. 2:08:30code base got big enough that
  3269. 2:08:31investigation didn't belong in the main
  3270. 2:08:34context.
  3271. 2:08:35And that's the progression to remember.
  3272. 2:08:38Don't start every project by enabling
  3273. 2:08:40every Claude code feature you know.
  3274. 2:08:43Instead, let the problem you have create
  3275. 2:08:45the reason to use that feature. Is that
  3276. 2:08:48everything you need to know about Claude
  3277. 2:08:50code?
  3278. 2:08:51Well, definitely not. You just learned
  3279. 2:08:53how sub agents let Claude split the work
  3280. 2:08:56into separate contexts so different
  3281. 2:08:58parts of a problem can be investigated
  3282. 2:09:00independently. But you can take that
  3283. 2:09:02same idea much further. What if those
  3284. 2:09:04agents don't just investigate different
  3285. 2:09:07parts of the application? But what if
  3286. 2:09:09they start building different features
  3287. 2:09:11at the same time? Well, Claude code has
  3288. 2:09:14a solution for that, too.
  3289. 2:09:15You can combine agents with isolated Git
  3290. 2:09:18work trees. So each agent can work on
  3291. 2:09:21its own copy of the repository while
  3292. 2:09:23building features in parallel. And
  3293. 2:09:25that's where you start getting into the
  3294. 2:09:26more advanced side of Claude code.
  3295. 2:09:30Parallel feature development, Git work
  3296. 2:09:33trees, MCP servers, and there's also
  3297. 2:09:36hooks to automate your actions.
  3298. 2:09:39Multi-agent workflows and complete
  3299. 2:09:42production engineering workflows such as
  3300. 2:09:44the one that I've built on top of Claude
  3301. 2:09:46code for professional software
  3302. 2:09:48engineering.
  3303. 2:09:49But yeah, sub agents are really just the
  3304. 2:09:51beginning of that idea.
  3305. 2:09:53You learn how to separate the context,
  3306. 2:09:56but the next step is learning how to
  3307. 2:09:57separate the actual work happening
  3308. 2:10:00across multiple agents at the same time.
  3309. 2:10:04But that's a story for another day. Or
  3310. 2:10:06another video at least. If you'd like to
  3311. 2:10:08see an advanced version of the Claude
  3312. 2:10:11code crash course,
  3313. 2:10:12leave a like, share the video, and let
  3314. 2:10:14me know down below in the comments. If
  3315. 2:10:16you request it, I'll make it.
  3316. 2:10:19With that in mind, let's go to the outro
  3317. 2:10:21because I have something important to
  3318. 2:10:23share with you.
  3319. 2:10:26At this point, you've gone quite a bit
  3320. 2:10:28further than simply opening Claude Code
  3321. 2:10:31and asking it to build something. You've
  3322. 2:10:33learned how to give Claude proper
  3323. 2:10:35project context with Claude and agent
  3324. 2:10:38CMD files.
  3325. 2:10:39Control what it can do with permissions.
  3326. 2:10:42Use plan mode when the approach matters.
  3327. 2:10:45Turn repeatable processes into skills
  3328. 2:10:48and delegate focused work to sub agents
  3329. 2:10:51without filling your main context.
  3330. 2:10:53And honestly, this is where Claude Code
  3331. 2:10:56starts becoming much more interesting.
  3332. 2:10:59Because once you understand those
  3333. 2:11:01pieces, you can start building much
  3334. 2:11:03larger workflows around them. For
  3335. 2:11:05example, the next thing I would normally
  3336. 2:11:08teach are using Git work trees, so
  3337. 2:11:11agents can safely work on different
  3338. 2:11:13features at the same time.
  3339. 2:11:16Connecting Claude to external tools
  3340. 2:11:18through MCPs. Using hooks when something
  3341. 2:11:21should happen automatically every time.
  3342. 2:11:24And combining everything into a complete
  3343. 2:11:27engineering workflow where Claude can
  3344. 2:11:29plan, build, verify, review, and even
  3345. 2:11:32coordinate work across several agents.
  3346. 2:11:36And that's where you stop using Claude
  3347. 2:11:38Code like a really powerful coding
  3348. 2:11:40assistant. And start treating it more
  3349. 2:11:43like an actual engineering system around
  3350. 2:11:46your application. So, here's what I'll
  3351. 2:11:48do.
  3352. 2:11:49If this crash course gets enough likes
  3353. 2:11:51and comments, and you want a more
  3354. 2:11:53detailed video,
  3355. 2:11:55I'll continue from exactly where this
  3356. 2:11:56lesson ends and cover the next layer in
  3357. 2:11:59detail.
  3358. 2:12:00Work trees, MCPs, hooks, multi-agent
  3359. 2:12:03workflows. And if you already got that
  3360. 2:12:05Claude Code cheat sheet, that means I
  3361. 2:12:07have your email, so whenever I do put
  3362. 2:12:09that video out, I'll let you know via
  3363. 2:12:11email. But, if you don't want to wait,
  3364. 2:12:14and if you want to immediately dive much
  3365. 2:12:16deeper than that second video would go.
  3366. 2:12:19The agentic engineering course that I
  3367. 2:12:20showed you earlier already covers that
  3368. 2:12:23entire layer.
  3369. 2:12:24From parallel feature development and
  3370. 2:12:26isolated work trees to hooks, automated
  3371. 2:12:29verification, and the complete process
  3372. 2:12:32that I use on larger applications and
  3373. 2:12:35even existing codebases. As part of it,
  3374. 2:12:37I'll also hold a live workshop that you
  3375. 2:12:40can join and ask any questions you might
  3376. 2:12:42have.
  3377. 2:12:43So, I'll link it below. For now though,
  3378. 2:12:46you already have everything you need to
  3379. 2:12:48start building very differently with
  3380. 2:12:50Claude Code. Don't try to use every
  3381. 2:12:53feature just because you learned it.
  3382. 2:12:55Start with the basics.
  3383. 2:12:57Give Claude Code good context.
  3384. 2:12:59Keep your tasks small.
  3385. 2:13:01Review what it does.
  3386. 2:13:03Turn repeated processes into skills. Use
  3387. 2:13:06sub-agents when work can happen
  3388. 2:13:08separately. And slowly give Claude more
  3389. 2:13:10freedom as you understand how it behaves
  3390. 2:13:13on your own projects. That's the
  3391. 2:13:15foundation.
  3392. 2:13:16And everything after this is scaling
  3393. 2:13:18that approach to a larger applications
  3394. 2:13:21and more serious engineering work.
  3395. 2:13:24And when you're ready for that,
  3396. 2:13:26you know where to find it.
  3397. 2:13:27Now, go build something.
  3398. 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.