Full Claude Code Tutorial for Beginners - Become A Pro Without Coding

0:00 There are two kinds of people using AI right now. People who type a question into an AI chatbot and get an answer and people who tell Claude to build the whole thing for them and just watch it happen. By the end of this video, you'll be the second kind. And before you think this is only for people who already know this stuff, it's not. The first time I open Claude Code, I had no idea what I was looking at. But that's changed. Your screen now looks less like code and more like a Google search bar. You literally tell it in plain English what you want.

0:28 And like a genie, it starts building it for you. Want an app? Abracadabra. It builds one. So here's how this works. First, we unlock the five superpowers of claude code and we learn them by building a real app together live on the internet. Then same tool, we run a full data analysis and build a complete investor pitch deck. And then the fun part, the bonus. Just last week, Claude dropped a brand new model called Opus 4.8. And it does something I'd never seen any AI do before. It's called dynamic workflows in which Claude runs a whole team of agents at once and it catches and fixes its own mistakes. Now, this is a full masterass, not a quick tip. So, open claude code on one side, this video on the other, and build with me to make it easy to follow. I've put a full Claude code cheat sheet in my free WhatsApp community, links in the description, grab it and keep it open as we go. And here's the thing, if you actually finish this, you'll be in the rare 1% who walk away with three real projects and proof you can build with AI. That's exactly what companies are desperate for right now. So, whatever you build today, post it on LinkedIn X, Instagram, and tag me. I'll reshare the best ones so your work gets the attention it deserves. Now, let's build your first thing together.

1:46 What we're going to build today is a job application web app. Something where you can track the jobs you're applying to see what you've already applied for, follow up on what's pending, and stay on top of your entire job search in one place. Think of it like task management, but built specifically around your job applications. The first thing we need to understand is what cloud code actually is and how you start working with it. If you want to use claude code as a non-technical person, there are a few different ways to approach this. But the best path I'd recommend is to download the Claude desktop app directly. When you go to claude.ai/d download, you'll land on this page where you can install the desktop app and it's available for both Mac and Windows. On top of that, you've got the Android app, the iOS app, and you can also install it on Chrome as an extension. You can pick whichever one fits your setup, but the cleanest experience is on Mac OS. That's where everything really comes together and that's how I'd suggest you get started with Claude Desktop. Once you install Claude Desktop, the interface looks something like this. If you notice, there are three tabs sitting at the top.

2:53 The first one is the chat tab, which is your regular Claude interface, the one you're probably already familiar with. The second tab is co-work, which is a completely different kind of interface, almost a different experience altogether. And if enough of you tell me in the comments that you want to learn about co-work, we'll do a separate full master class on that. The third tab is claude code and that's where we're spending our time today. This whole panel you're seeing here is what we're going to work with. This section gives you the models that are available, which models you've been using and the usage breakdown. So you can see what your usage has looked like over the past 30 days and the past 7 days as well. Now, let me show you the very first step to start building any kind of application with cloud code. The first thing you need to do is create a folder on your computer where this project is going to live. I've already created one beforehand, but let me walk you through it. I'll open this up and then open another folder right here. The folder I want to create is a fresh one for our job search copilot. So, I'm going to call it job_arch_copilot.

3:57 Simple and descriptive. And there it is. The job search copilot folder has been created. I'll open this new folder. And as you can see, it's now showing up. Right now, it's completely empty. There is absolutely nothing inside it. Just a clean slate to start with. As we go through this masterass, you'll see this folder slowly fill up with files and how we work with everything that goes inside it. ahead with this setup. One important thing to flag before we go further to use cloud code, you need at least the pro plan. In some countries, Anthropic is experimenting with new ways of introducing cloud code. So things might shift a bit depending on where you are, but from my actual experience using this every single day. If you really want to get the most out of cloud code and build real apps without constantly hitting walls, you should ideally be on at least the $100 plan. That's the one I'm on.

4:48 That's the max plan. To break it down, there are three core plans. The free plan on which you cannot use cloud code at all. The pro plan, which technically gives you access, but the usage is very limited. And what tends to happen is by the time you get into the flow of doing something meaningful, your context window runs out. Your usage limits get hit and you're stuck waiting. And then the max plan, which is the $100 plan, where you get the real headroom to use the application properly, the way it's meant to be used. The next thing you need to wrap your head around is the settings, specifically the different models available to you. If you look closely, you'll see there are multiple models listed. And the easiest way I can explain these is by comparing them to the gears of a car. Imagine you're heading out for a normal stroll around the city. You're not pushing the car.

5:36 You don't need any heavy power for that. That's exactly where the Haiku model fits in. It's the lightest, easiest model, the one you'd use for everyday simple tasks. If there's some actual thinking involved, something a little more layered, that's when you switch to the Sonnet 4.6 model, which has a lot more reasoning capability built in. And then for the really heavy lifting, the tasks that need deep, complex, multi-step thinking, you use the Opus 4.71 million model, which is the heaviest gun in the lineup. These model names are going to keep changing over time. Anthropic is constantly releasing new versions, so don't get too attached to the specific names, but the structure stays the same. Think of haiku as your normal stroll, sonnet as your regular city driving, and Opus as your steep mountain hike where the thinking goes deeper. The response takes a little longer. And yes, it is pricier to run.

6:27 Right next to the model, you'll notice this thing called effort. Effort is basically the dial that controls how long the model thinks before it gives you an answer. When you do need it to think properly, setting it to high is more than enough for most use cases. you don't really need to go all the way up to extra high or max or start enabling fast mode that's not necessary for the kind of work most of us are doing. Maybe if you're building something really large and complex like a serious production scale application, then yes, you can play with those higher tiers, but for the vast majority of cases, high is a solid default. If you're doing simple day-to-day tasks that don't involve any coding at all, you can drop down to medium or even low. But the moment you're trying to build an application, high is the setting you should lean on. So high effort, that's something you need to be intentional about as you're working. This is how you should be managing your effort overall.

7:21 If you're on a lower plan, you have to be really strict about how you spend your effort because you don't have unlimited room to play around. If you're on a higher plan, you've got a lot more flexibility. You can mix and match across tasks. But the simple rule of thumb is this. For difficult tasks, you go high and for normal or easy tasks, you stay on medium. For example, if you're just asking the model to read a document, reading a document is not rocket science. It doesn't need deep thinking. So there you can drop down to medium or even low effort and just ask it to read through and give you the gist. But the moment you're asking it to think through something or build something or solve a real problem, that's when you bring it back up to medium or high. So it has the actual room to do the job properly. That's the overview of the models. And you'll see all of this come up naturally the moment you start chatting inside Claude Code.

8:08 The next thing you need to understand just as important as the models is the permission setting. There are five modes here and each one changes how much control the AI has versus how much control you keep in your own hands. The first one is ask permissions where at every single step claude code stops, checks in with you and asks for permission before it does anything. You're approving every action one by one which feels slow at first but gives you the tightest grip on what's happening.

8:35 The second mode is accept edits which is more streamlined where instead of pausing at every step, Claude just accepts the edits wherever it can and lets you keep moving without interrupting the flow. The third is plan mode and this is the one I personally love because in this mode you're not asking the AI to execute anything. You're asking it to create a plan first and share that plan with you for approval. The fourth is auto mode which is basically you telling the AI, okay, I'm handing you the keys. You're on autopilot now. Just go. And the fifth is bypass permissions, which is the trickiest one of the lot. Bypass permissions is something I'd only recommend if you're an expert and you're working inside an isolated folder where nothing important can break. Because in this mode, the AI executes everything in a completely uninterrupted manner with zero checkpoints from you. Now, before I build anything, I always go into plan mode first. Think of it like agreeing on the route on a map before you pull out of the driveway. I want the AI to figure out what I'm trying to do, lay out the entire plan, and only once I've reviewed it and approved it, then I let it actually touch a file. This one single habit will prevent 90% of those, oh my god, I've built something completely wrong moments that beginners run into all the time. Now, let's start with our first project, our build number one, which is a web application. When you are doing the build, there are five things you should always think about whenever you ask for something big. What you want to build, who it is for, what it does, what it looks like, and anything specific you want included. So, watch how I structure this prompt. Plan a web application. Do not build anything yet.

10:14 Interview me and show me the plan first. What I want you to build is a job application tracker web application. For whom? Me, Vebav, a job seeker who is nontechnical. What it does is that it maintains a pipeline board with columns like wish list, applied, interviewing, offer, and rejected. So I can add a job either by pasting a URL or by pasting in the text of the listing. Each job becomes a card that I can drag between columns as I move through the process.

10:42 When I click on a card to open it, there's a generate kit button that produces a tailored cover letter, four rewritten ré bullets, five likely interview questions, and a one-page company brief all in one shot. The look I'm going for is a clean modern application overall. And for the AI part of it, I'm going to use open router. So that's the complete understanding of what I want to build handed over in one clean prompt. Now what I'm doing here, just so you understand, is I'm using open router. And open router is something worth explaining for a second.

11:14 Open router is essentially a unified interface for large language models. Which means instead of signing up separately for OpenAI, Anthropic, Google, and every other AI provider out there, you sign up once on Open Router and you get access to all of them through a single account. You can head over to openro.ai and see this for yourself. If you look here, you'll find every model that's available. If I search for Opus models, I get all the Opus APIs listed right here along with the pricing per token. Once you sign up for a plan, you'll be able to explore over 400 different models, which is honestly a crazy amount of choice for one platform. To actually use Open Router inside your build, you need to create something called an API key, which is basically a unique password that lets your application talk to the AI models. The steps are straightforward. You go to open router.ai AI. Head into the model section, then jump into credits, and you need to make sure you have sufficient credits loaded into your account. $11 is more than enough for what we're doing today. Then you head into API keys. And here you click on new key to create your API key. When you say create an API key, it's going to ask you to give it a name.

12:26 And you can leave the credit limit blank if you want. Once that's done, it generates the API key for you. And that's the key you're going to plug into your application. where exactly that key goes inside the app. I'll show you when we get to that part of the build. Now that we've created our API key and have everything in place, this is the moment we actually start chatting. I've handed over the full brief and now Cloud Code is going to take that and build it for me. Remember I said do not build anything yet, just plan. So, it's going to respect that and start with the plan first. The session has officially started and right now it's thinking mode it's thinking. It's trying to understand what this application actually is. What is it that I want to build? What is it that I want to do? It's working through all of that in the background. The first thing you need to understand is that we're working inside our local directory itself. And right now, it's an empty directory, a completely fresh green field build with no existing codebase to explore. So, it has nothing to reference, which means it has to ask me to fill in the gaps. And that's exactly what it does next. says, "Let me interview you on the key decisions before I write the plan." So, it's asking me for the key decisions one by one. First question, how do you want to run and access this app? My answer is I want to deploy it online eventually, but don't worry about that right now. We'll talk about a simple deployment method later in this video. For now, I'll build it locally first and then I'll deploy it once it's working. Next question. Where should your jobs and cards data be stored? You've got three options. either browser local storage, a local database file sitting on your machine, or a full cloud database. If you're going down the cloud route, Superbase is a great option, but I'm going to go a little simpler for this build and use a local database file, which means everything lives right there in your project folder. Next, the AI features, the cover letter, the resume bullets, all of that.

14:14 They need your base resume to work from. How do you want to handle that? Two options. either save it once inside the settings or upload it as a fresh PDF every time. I'll go with upload PDF or docx because that gives me the flexibility to switch rums depending on the job. Then it brings up something important. Pasting job text always works but autofetching a job from a URL often fails because a lot of job sites block automated requests. So how should URL handling work? The answer here is first try to fetch and extract automatically and if the site blocks it, prompt me to paste the description manually as a fallback. That's the most robust setup and that's exactly what I want. Now it's going to ask me a couple more questions to lock the plan down completely. Which open router model should power the AI kit generation? I'd say clouds on it. I think it's the best quality for this kind of work. So we'll use that. After the AI generates a kit, what do you want to do with the output? Let's choose edit, then save. because I want to be able to tweak the AI output before it gets locked in. Then it asks me to choose a stack, something that's suited for a non-technical owner. I'll just say keep it simple. Use your recommended text stack. As a non-technical person, don't break your head over this one.

15:27 Just go with the recommended text stack. That's the easiest path forward. So now it's going, if you look here, the number of tokens being used is shown right on the screen. And that helps you understand what's happening as the model is working. And if you look at what it's producing, it's actually creating a full plan document for me. The plan is called plan a web application. And this is the structure it has laid out. The job application tracker, the context, the decisions, the architecture, the data model, the key flows, the open router integration, files to create, design, and the overall look and feel. Now, this is the moment where if you have a particular design in mind, you can step in and override what it has proposed.

16:07 And because I do have a specific design in mind, I'm going to say revise. I want to use the brand language of linear, which is a popular task management software with a really clean visual identity. And to do that, I'm going to use linear design. MD file. For this, there's a website called getdesign.md, which is honestly a gold mine. What they've done is collected the design.md files of some of the most popular platforms out there. So, you can borrow their design language for your own builds. Linear is one of the most popular ones on there. So I'll click on linear and inside linear entry I'll click on the design MD file. So now I have the complete design MD in front of me I'll go into the design.mmd itself and I'll copy the whole thing. This is the design MD I'm copying and I'm going to paste it directly into clot code giving it my design preference in one shot. I'll tell it here is the design I want to use. Use this design MD. Quick note for anyone unfamiliar. MD or markdown is just a simple formatting approach that lets you structure documents in a clean way that machines and humans can both read easily. So I'll paste the complete design and I'll hit revise. What I'm essentially doing is I already have a plan that's been generated, but I want to revise it specifically on the design side before anything gets built. If you want to make any changes to it, all you have to do is leave a comment directly to Claude and it adjusts. Let me check if the plan revision has actually gone through.

17:25 Design look and feel linear dark system. There we go. The linear design language has now been logged into the plan. Now I can move into accept and auto mode. Auto mode means it'll only ask me for particular permissions when it really needs to. It won't stop me at every single step and ask for confirmation on every tiny thing. So all I have to do now is accept and let it get started. But before it goes off and does anything more, there's one important thing we need to do first. We are going to learn a few superpowers that make building this project easier. The first superpower you need to learn is commands. A command is just a reusable prompt. You can write a long instruction once and ask cloud code for it forever with one simple slash. Let me show you.

18:05 The command I want to talk about right now is slashinit. What slashinit does is set up the memory of your project. And here's why that matters. You're building this product, but realistically, you're not going to finish the entire thing end to end in a single session. At some point, you're going to close the laptop, come back tomorrow, and pick it up again. When that happens, you want the context of what you've already done to be remembered. Some project specific information needs to persist across sessions. So you have to give Claude what's essentially an onboarding document that it reads every single time it starts a new session. When you run /init, claude scans the entire folder and writes a file called claude.md which becomes its memory for this project going forward. So I'll type /init and hit enter. The command/init has now been triggered and it's going to initialize that clot.md file inside my folder. It's asking me for permission to write the design md and the clot.md file. So I'll say always allow because I wanted to be able to write these without stopping every time. Once I hit auto mode, Claude takes over and just starts building.

19:05 This part of the process takes a few minutes. And the good news is you don't have to do anything during the stretch. Claude reads the plan, reads the design and just executes the whole thing. Once in a while, it'll pop up and ask for a permission. You click always allow and it keeps moving. I'm going to fast forward through the build here because there's genuinely no point in watching files appear on screen for 5 minutes straight. But what I want you to notice in this stretch is that the entire structure of the app is being created without me touching anything. So here I gave autopilot mode to Claude and let it build the entire app. You can see that at particular places it's still pausing and asking for permission which means it's still realizing which are the important moments and not just charging through blindly. One thing to remember here I'm directly using Opus 4.7 even for the build itself. If you want to be a little more economical, you can switch this model down to set during the build phase and save up on a fair bit of usage since OPUS is significantly pricier to run. But I'm just going to proceed with Opus for the sake of this walkthrough.

20:07 So the complete setup has been done. The code has been written. All the files are in place and it has created everything that needed to be created. Now I have to step in and do the checking. I have my API key ready from the open router step earlier. And now I need to put that API key into the right place inside this project. To do that, I'm going to go into the same folder we've been working in this whole time. And I'll open it up.

20:31 As you can see, all the files are sitting right here. Now look for this one specific file called enenv.example. What I'm going to do is make a copy of this file. Paste the copy right back into the same folder and rename the copy to just env. So that's the name we're going with. And this env file is where the API key actually needs to live. So I'll open it up. This is the line where I paste my API key. And these are the other settings sitting underneath that I need to be aware of. I'll copy my API key from open router, paste it in here, and save the file. So that part is ready. Now I'll come back to cloud code and tell it. I created a env file. Quick explainer for anyone wondering what that even means. Eenv stands for environment file and it's a special file where all your API keys and secret credentials are meant to live separate from the rest of your code. Now here's something really important to remember. Your API key is extremely sensitive. Please make sure you are not sharing this API key with anybody outside. Not in screenshots, not in screen recordings, not in any chat.

21:33 Think of it exactly like the password to your bank wallet. If somebody else gets hold of your API key, they can run up usage on whatever subscription you've paid for and you'll be the one footing the bill. So, let's tell Claude, I created av file and pasted the API key there. Now, run it and check. What it's going to do now is verify whether the env file we just created actually has a valid API key sitting inside it. It runs a minimal test call in the background to confirm everything is wired up correctly. It's checking with open router to see if the key we've added is real and active. It's authenticating right now and it comes back saying the key is valid. That's a good signal. It means the entire pipeline between our app and the AI is now connected. So the end toend testing has happened and everything is hooked up. What we can also do is take a look at the files directly. You've got multiple files showing up here. You can click on index.html and view all the data, all the content.

22:31 You can see exactly what has been built. The other way to look at it is by clicking on preview, which gives you a live look at what the application is going to look like once it runs. All right, so everything is ready. Now we can actually test our application for the first time. We'll open this up. It looks like it isn't running yet. So let's reload it. In fact, let's tell it directly run the app and tell me if it is running. So, it's going to start the app in the background and let us know once it's ready to view. All right. Now, we'll open this up. And here we are.

23:00 This is the homepage of our application. The pipeline is ready and live. You can hit add job right away if you want. But before we do that, let's first go into settings and upload the resume because the AI features won't work without a base resume to reference. For the resume, what I'm going to do is head over to my LinkedIn vibes. This is my LinkedIn profile right here. From here, I'll click on more and then save to PDF.

23:22 And just like that, my profile is exported and saved as a PDF ready to use. Now I'll go back to the board. From here, I can either add a job by pasting a URL or I can paste the job text directly. Now remember, some sites won't allow our app to fetch the listing automatically. So let's go test exactly that scenario. I'll go to an AI operations lead role. This is a job post by Apple AI operations lead. First, I'll copy the URL of this listing and paste it into our app. Then we hit add the job and see whether it manages to pull the listing or not. And as expected, it could not read the page automatically because Apple's site is blocking the fetch. So instead, I'll just copy the full job description from the page and paste it directly into the app, which is the fallback we set up earlier. Now the wish list has AI operations lead original content operation sitting on it as a card. Let me click on it to open it up. Right now there's no kit ready for this job. So I'll hit generate the kit.

24:13 And there's a really neat detail here. You also get a view original posting link. So you can always jump back to the source whenever you need to. So I'll generate the kit. And what this is doing in the background is creating the tailored cover letter, the rewritten resume bullets, the five likely interview questions, and the onepage company brief. All of it tied directly to this specific job and my resume. There we go. The cover letter is ready.

24:36 It reads, "I'm writing to express my strong interest in the AI operations lead role as a founder of a tech platform that has served over 1 million learners. So, I've got my cover letter tailored to this exact job, and I can copy it directly from here and use it wherever I need to. Below that, I've got the resume bullets, the specific lines I can swap into my resume to match this role better. Then, below that, the interview questions, basically, the five things I'm most likely to get asked if I land this interview. And finally, a company brief on what Apple does, the context I'd want to walk in with. So far, this is exactly what we asked for.

25:08 I can keep adding jobs like this, and the workflow keeps moving forward. If you watch this, when I drop this card over here, it moves into applied. So I can drag from my wish list straight into the right column as my status changes. And just like that, I have a complete working job application tracker running. So to some extent, what we've just built is version one of the software. And from here, we can make it even better. Now for the main version of the app, what I can do is type something like updatecloud.md.

25:36 Now it goes in and refreshes its memory of the project. So the next session it opens, it knows exactly where we left off. So everything is running smoothly. Now I want to introduce you to the second superpower, which is skills. A skill is like a pre-written playbook that your best teammate already wrote down for you. And Claude pulls it out automatically the moment it fits the situation. So instead of constantly describing to Claude the changes I want for my UI, for example, my UI should look like this, my UI should look like that, I can use something called a skill, which permanently teaches Claude how I want things done. Now, Claude Code already ships with a whole bunch of skills built right in, like a front-end design skill. Think of this front-end design skill as a recipe for making a specific dish, except this recipe was written by one of the best chefs in the world. This particular front-end design skill was actually built by the anthropic team themselves. Inside it, they've documented exactly how a great front end should look. The spacing rules, the type hierarchy, the visual rhythm, all of it. So, if you're someone who isn't a designer by trade, you can use the front-end design skill to look at your existing design and elevate it without needing to know any of the underlying design theory yourself. Now, how do you actually call such a skill into action? You do it using the slash command. You can either call it directly by typing the slash command or you can simply say something like elevate the front end of my application and it'll be invoked automatically. Both roots work.

27:03 Both will trigger the skill. So go ahead and say using this skill, can you relook at the front-end design and make it better instead of asking it to fix one specific element, you want it to go through and improve all the elements at once. It's a step-by-step procedure laid out in detail. And Claude uses that step-by-step procedure to take things forward. Now something interesting happens here. Your existing design system which is the linear design we locked in earlier and the front-end design skill which has its own playbook of design rules are slightly conflicting with each other. So you'll need to guide it. For example, refine within linear itself. There's already a system in place or else refine inside that boundary rather than starting from scratch. It comes back and asks what should I prioritize making better? let's say make all the elements better because we want a full design pass across the entire app. So now it's going to update all the to-dos and get to work. One thing you should really internalize here is that this whole process is iterative and patient. You build one level of functionality, then you stack another layer on top of it, then you keep refining. That's the rhythm of building with cloud code. So now it's working on making things better. And you'll see it makes a bunch of subtle modifications to elevate the design based on the rules inside the skill. Right now it's saying everything is good. So let's actually go back to the app and see what changed.

28:22 Look at this. There's a real visible improvement. It has completely refreshed the UI compared to what we had a few minutes ago. Let's go through it from the top. First thing to do is head into the settings. The resume is already in there from before. So that's fine. You can replace it if you want, but there's no need right now. Head back to the board for a clean test. Close this open card. Delete the existing job and start fresh. Look at this. Track every application in one quiet place. Add a job. So instead of just an empty board staring back at you, it now greets you with this prompt that says add your first job. Click on it. And since we already know from earlier that the copy paste route is the one that works reliably, just copy the job description and say add the job. There you go. The job is posted. Look at this. the subtle animations when you click on it. That's a really nice touch that wasn't there before. Click into this card and hit generate the kit. And there it is. Look at how it's animating it. In the earlier version, we didn't have any of these animations at all. They've shown up now purely because of the front-end design skill we just ran. And these animations actually serve a real purpose. They keep the user engaged during the moment when the AI is working in the background, which would otherwise feel like dead time. There we go. The kit is ready and if there's anything you want regenerated, you can do that with one click. What Apple does, what original content operations means, all of it is laid out. So now we can close this card.

29:49 If you open it back up, all of this content is still saved, which means you can either regenerate it later or use it exactly as it is. You can drag it across to any column and just like that, your complete job tracker is ready and working. Now, we can still push this further. For example, look at the resume bullets and the interview questions. Their formatting could honestly be a little cleaner. This right here is what markdown looks like before it gets rendered properly. It can be displayed in a much nicer, more readable format.

30:19 So, you'll give that feedback directly. Here's what you'll type. Once I generate the kit with AI, I want the content to also look better. Currently, the formatting is off. I want it to be rendered in markdown and not just displayed as raw text. Submit that. This is exactly what I meant earlier about it being an iterative patient process. You build one level of functionality, then you keep stacking improvements on top, one feature at a time, and now it's saying everything is good. Head back and check. It does look noticeably better, as you can see. And the whole thing reads much cleaner than it did a few minutes ago. The resume bullets are far more readable now. You could push it even further if you wanted, but we're clearly moving in the right direction.

31:01 Now, this is the perfect moment to bring up something important. We just walked through how to use the front-end design skill, which was a skill built by Anthropic. But the really powerful thing is you can build your own skills, too. So, how do you actually build a skill? It's surprisingly simple. You just have to tell the AI to build the skill for you. So, here's the prompt to use. Create a custom skill called scope a feature in this project. What it should do is whenever you say I want to add a feature, the skill makes Claude ask you a good amount of sharp clarifying questions about the feature and the edge cases. Recommend what other features you could build on the ideas you already have. Supply you with more ideas. Then ask you the questions, wait for your answers and restate the plan in one paragraph. Once you approve it, then only should it build the feature.

31:48 Overall, try to use the best practice as possible and keep the skill as short as possible. So go ahead and execute that. Now notice you didn't tell Claude how to create the skill. You only told it what the skill should do. That's because there's already an existing tool called skill creator that can generate any skill you describe. So Claude already knows how to make skills. You don't need to teach it the process. You just tell it what you want. So Claude runs the skill creator behind the scenes and it produces a file called scope aer feature. That's the skill saved permanently into your project. From now on, anytime you trigger it, Claude will follow that exact playbook without you repeating the instructions. And here, Claude has summarized how the skill works. It's a four-phase gate. Phase one, sharp clarifying questions. Phase two, adjacent ideas, things you could build alongside what you're asking for.

32:37 Phase three, wait for your answers, then restate the plan in one paragraph. Phase four, the approval gate, where it only builds after you explicitly approve. So with this simple process, just by describing what you wanted in plain English, you've built your own custom skill that lives inside the project. Now let's actually use it. Call the scope a feature skill. The next feature to build is an automatic job searcher, something that searches live jobs based on your profile. It should ask you questions if it needs more context and tailor the jobs to you. The open router API key is already set up. So think of a model that can help search for live jobs like the perplexity models which are built for realtime web search. So now Claude is building the feature, the plan has been approved and it's just executing in the background creating the find jobs page adding the search routes wiring up perplexity through open router. The skill we built the scope a feature skill already did its job. It interviewed you locked the plan and now claude is just running. And there you go. The build is done. Now, let's actually go and check whether the find jobs feature works the way we wanted it to. First, let's demonstrate adding a job manually. Grab the description, copy the URL from the Apple Careers page, and paste it over into the app. Click add job. There you go. The job has been added to the board.

33:58 AI operations lead is now sitting in your wish list column. Now, jump to the find jobs tab. This is the new feature you just built. And right away, it's telling you no ré saved yet. So you'll have to head to settings first and upload your resume before this can work. Once you do that in the titles, type head of marketing. For location, put San Francisco. Leave work mode as any and click find jobs. Now look at this. It's saying searching the web in real time.

34:23 This is the Perplexity Sonar model that you wired up earlier doing its job in the background. And there you go. It has returned three matching job listings for you. Add a couple of these straight to your wish list. Head back to the board now and you can see all three jobs sitting in your wish list column. perfectly slotted in. Click on one of these new jobs to open it up and hit generate an application kit. It'll automatically create the tailored cover letter, the resume bullets, the interview questions, and the onepage company brief all in one go. And there you go. The kit is generated. The cover letter is ready, the tailored ré bullets are ready, the interview questions are there, and a company brief on what the company does. All of it generated based on your profile and the job description.

35:03 So that's the complete find jobs flow working end to end. Now come back to the terminal back to claude code. There are a few more important commands you should know. The first one is / usage. Type / usage and hit enter. And it shows you your plan usage broken down clearly. You see here there's a 5-hour limit. There's a weekly limit and it tells you exactly how much of your token quotota you've consumed so far. This is very very important to check regularly because if you don't check, you might hit your limit at the worst possible time. say in the middle of a big build and then you're just stuck waiting. So make slash usage a habit. Keep checking it as you work. Now here's a best practice you should burn into memory. Whenever you're getting close to your usage limits or you've just finished a significant feature, run updateclaude.md.

35:50 This documents all the progress you've made so far into that memory file you set up at the start. That way in the next session, Claude has full context of where you left off and doesn't lose any of the work. If you look here, about 22% of the context window has been used right now. And here's a very important rule. You should not let this context window cross 50%. If it goes beyond 50%, the AI starts degrading. The responses get sloppier. It forgets earlier instructions. Things go off the rails.

36:21 This phenomenon is called context rot. So before you start managing your context size, the crucial step is to update claude.md first because once you compact the context, you don't want to risk losing the work you've already done. Update cla.md first that locks your progress in safely. The next command is /compact. This condenses the conversation history. It removes the unnecessary tokens while retaining the essential information overall. So this is the standard workflow you want to follow. update claude.md first, then run /compact. This pair together is what helps you maintain efficiency on larger projects. Without this rhythm, your context will keep growing and at some point the AI will start to degrade. So now it's running the /compact command.

37:06 This can take a moment because it's analyzing the entire context to figure out what to keep and what to drop. And there you go. The compaction is complete. If you look at the context window now, it has dropped from around 22% all the way down to about 7%. So you've just freed up a huge amount of space for further work. This brings us to the third superpower, which is hooks. This lets Claude Code automate work behind the scenes. A hook is like an always on rule. Think of it like an automatic spell checker. It triggers without you having to ask for it. When you're typing in Word or Google Docs, the spell checker is running quietly in the background. you don't call it. It just shows up the moment you make a typo. That's exactly what a hook does.

37:48 It sits there, waits for something specific to happen, and then it runs on its own. So, let's create a hook for your project. Something genuinely useful, a real automation. Here's what you want it to do. Every single time you build a new feature, you want it to automatically update your claude.md because right now, you have to remember to run update cloud.md every time. And let's be honest, you'll forget. So type it out. I want to create a hook. What this hook should do is once a new feature is implemented and tested, it should automatically update cloud.md.

38:21 And see this is the real beauty of cloud code. You don't need to know any code to execute this. You just describe the behavior you want in plain English and it'll figure out how to build it. So go ahead and run that. Now it's asking how should the cloudmd update be triggered. There are options here. One is the stop hook which runs automatically every turn. The other is a manual/ ship command. You want this to be fully automatic. So go with the stop hook. Now it's asking what should count as the signal that a feature is actually implemented and tested. Go with your own judgment on this one. So whenever you decide the feature is done, that's the trigger that fires the hook. Now Claude is creating the hook in the background and you can see the logic it has implemented. It's checking if the source files have changed. Now let's clarify something important because three different terms have come up so far and you want to remember the difference between them clearly. A hook is an automatic rule. It just runs quietly in the background. You don't call it. A skill is a defined step-by-step recipe.

39:14 You call it explicitly and it follows the steps inside. And then there's a third concept which is called a command. A command is essentially a reusable prompt. It saves you time when you're doing repetitive tasks. So instead of typing the same long prompt again and again, you save it once as a command and from then on you just call it with one slash. So let me show you. We'll build a custom command called ship. Type it out.

39:35 I want to build a custom command called ship. So that when I run this command, it should summarize in the session what I did and how. If I am writing code or writing a document, what are the changes that have occurred based on the task, it should change. Let's run it. So let me show you. We'll build a custom command called ship. Type it out. I want to build a custom command called ship. So that when I run this command, it should summarize in the session what I did and how. If I am writing code or writing a document, what are the changes that have occurred? Based on the task, it should change. Let's run it. Now Claude is asking what should actually do with the summary. It's asking you to clarify the output behavior of the command. Select summarize in chat only. Now it's asking where should the / ship command live.

40:16 Say this project only. Now it's creating the file. So Claude is confirming and creating the custom command based on the specifications you gave it. So now both the automated hook and the custom/ ship command have been integrated into your project workflow. Let me test the command. Type / ship in the terminal. But look at this. It's coming up as plain text. It's not being recognized as a command yet. This is something important you need to know. Whenever you create a brand new custom command, you have to restart the Claude code environment for it to actually get picked up. So, restart it. Exit Claude and start it back up. Type Claude in the terminal to launch it again. The Claude interface is loading. Now, select your recent session plan application tracker web app. So, you're back in the active project session right where you left off. Now type / ship and run it. There you go. Claude immediately responds with a structured summary. So the slash ship command is officially working. This is how you build a custom command from scratch. So in this last stretch, you've actually built three different things into your project. You've built a hook, a skill, and a command. Three different tools, three different jobs. And the best part of it all is that none of this required you to write a single line of code yourself. Now let's unlock superpower number four, which is sub agents. So an agent is something that carries out a task for you end to end.

41:31 And a sub agent is a specialized helper that runs alongside the main agent focused on one specific job with its own separate context and its own dedicated workspace to think in. So when you're working inside cloud code, you're already interacting with an agent in the main session. What you can do on top of that is spin up sub aents to handle focused tasks in parallel without polluting your main conversation. So let's create two sub aents for this project. So you can actually see how they work in action. Just write a prompt for it. Say create two sub aents for me.

42:01 One sub agent is called code reviewer to find bugs and quality issues in my code. The second sub aent is a security reviewer to check for security problems in the app. Now the real advantage of sub aents is the headroom they give you. Each one gets a full 1 million token context window to play with, which makes them genuinely powerful for running heavy tasks in parallel. So if you ever need parallel execution on something, sub aents are the best way to handle it.

42:25 So you can see claude is finishing the creation of the code reviewer and right after that the security reviewer sub aent. Now to actually use these brand new sub aents, you have to restart claude code same as we did with the custom command earlier. So type /quit to exit out of claude and then just type claude again to start it back up. Resume the previous session and now you're ready to instruct Claude to run the agents. So say run the two sub aents in parallel the code reviewer and the security reviewer sub aents and give me the report. Notice once again you don't need any complex syntax for this. You can just explain in plain English what the agents should do and cloud figures it out. And the agents have started. You can see these two panels have opened up on the side. These are the background tasks running in real time. Both agents are running parallel to each other completely independently. This right here is the true power of cloud code.

43:16 You set up multiple agents and you can watch them run on the agent board without interfering with your main work. While the agents are running in the background, let me show you another useful command /btw. It stands for by the way, which is a nice touch. You can use it to check the status of your environment without breaking your flow. So /btw functions almost like a side chat. You can interact with claude while the main chat is busy doing heavy lifting. And there you go. The code and security review has completed. It has given you a clean list of findings that need to be fixed. Once the reports are generated, you can simply ask Lord to fix all the identified bugs in one go.

43:52 Here you can see the combined report and it details all the security and code issues present in the app right now. There are high severity issues and medium severity issues listed out clearly. So just type fix the main issues and Claude should be able to resolve everything that was flagged by the agents. And after all the changes are made, watch this. The hook fires automatically in the background. It updates claude.m MD concisely without you even having to ask for it. That hook we built earlier is doing its job exactly the way it was designed to. So the application is now ready and it's time to deploy this. App is now ready and it's time to actually deploy it. But before we get to that, let me quickly recap everything we've built so far because there's a lot of moving pieces and you want them all clear in your head. Think of it this way. Let's say you're cooking a dish. A hook is a single step. It's like tasting the food right after you add an ingredient. You just check quickly. Does it taste okay?

44:42 That's all a hook is. That one small automatic check that fires after a step without you having to ask for it. A skill, on the other hand, is a complete recipe. It's a full step-by-step playbook for making the entire dish from start to finish. An agent is the chef, the one who is actually doing the cooking, executing the recipe end to end. A sub agent is a specialized cook for side dishes, running parallel to the main chef, doing its own focused task on the side without getting in the way. And a command is a sudden instruction like a chef shouting flambeay in the middle of cooking. That quick reusable trigger you call out when you need it right now. So that's the whole kitchen working together to make the dish. On top of this, you have the final superpower which is MCPS or connectors. MCPS are the instruments, the tools like a pan or a walk that you need to execute specific tasks outside the AI itself. Without the instruments, even the best chef cannot cook. The MCPS are what let Claude actually reach out and do things in other systems beyond just your code editor. Now, you need a tool to deploy this code. So, let me show you where to find them. Head to the chat menu and here you'll find the connector section.

45:46 These are the MCP servers you can plug in and use. And look here, you can see Versel sitting in the list. Versel is the connector used for deployment. So, that's exactly the one we need. Click on browse connectors. And as you can see, Netlifi is also available right there. If you don't want to use Versel for any reason, you can use Netifi for the same kind of deployment. Both do the job well. Connecting these accounts is a pretty easy process. You just authorize it once and you're done. No ongoing setup needed. Now come back to your code window and here just type deploy this code on Versal. Now since Versel is connected as an MCP server, Claude can use it directly without any extra setup.

46:21 It can deploy small applications on the free tier itself. You don't need a paid plan for this. Now look, cloud is actually asking you how to proceed because running an express server on Versel requires some specific configurations to work properly. So it wants to know exactly how to handle that before it moves ahead. And here it's suggesting a simple rearchitecture along with adding a basic access gate. Before any public deployment, you want some basic protection on the app so random people on the internet cannot just walk in and access it. So click yes, go ahead with the access gate. Now let Claude handle the rest of the configuration.

46:53 You just choose to deploy and the AI takes it from there. This is where Claude really shines. Automating all the deployment for you. The kind of stuff that usually takes hours. Now, whatever is happening on screen is slightly technical. So, whoever likes can skip a few seconds to move to the next section. But here, basically, it's loading the versal tools and getting ready to apply the migrations. It's converting the local SQLite database logic to Postgress because Superbase runs on Postgress.

47:19 That conversion needs to happen for everything to work in the cloud. It's also cleaning up the local environment variables, getting everything ready for the cloud environment. And now it's finalizing all the versal configurations on its own. So as you can see, local SQLite is fine when you are just testing things on your machine. But when you want to take it online and share it with the world, you just connect a free Superbase account and a free Versal account and the AI handles all the complex transitions for you. Now from the connectors menu, you have to go ahead and connect the Versal MCP from the connectors list. the way I just walked you through. That's all you need to do and that's going to be sufficient for everything we're about to do next.

47:57 Quick thing I wanted everybody to see. Whatever we've been creating throughout this whole build, all of it is sitting inside the dotcloud folder. So most of the skills, hooks, commands, and agents we created are all present neatly inside the do.cloud folder, organized and saved. For example, if you go into skills and look at the scope of feature skill, open up the skill.md file, this is exactly what scope of feature looks like. Similarly, for hooks, there's a simple script that was written. Then you've got the commands, which is the complete prompt that was written for the / ship command. So, it's basically a reusable prompt saved to a file. And then you've got the agents. You have the code reviewer agent, which tells Claude how to work and exactly what to look for. focus specifically on code review areas. And there's the security reviewer agent, which also tells Claude what to look for and lists out all the security things to check. You don't have to be a tech person to come in here and read through any of this. Everything is laid out in plain English, properly organized, and every single thing you wanted to check is sitting right inside this folder, easy to find. Okay. So far, we have done a full app build, deployed it online with skills, hooks, commands, agents, and MCPs all wired in. But here's the thing you really need to know. Cloud code is not just for building applications. The same tool we just used to ship a web app can also do data analysis, write reports, explore data sets, and perform a lot of other heavy tasks. So, let's go to build number two, which is data analysis.

49:29 We'll do a walk through a completely different use case to demonstrate these capabilities. First create a different folder and call it data analysis. That's the workspace for the entire analysis we run next. Now we need some actual data to work with. So let's open up a site called Kaggle. If you've never used it before, kaggle.com is a place where you can find thousands of public data sets across pretty much every domain you can think of. Now let's search for a marketing data set because that's what we're going to play with for this demo.

49:58 Here's the search results for marketing data set. You can pick one of them. This particular data set has fields like year of birth, income, kids at home, teens at home, recency of purchase, and so on. It's a classic marketing analytics data set, the kind that has all the information you'd want on customer purchases, education level, household size, all of it laid out in one place. So, you can download this complete data set and once it's downloaded, move it into the data analysis folder we just created. That way, everything stays in one place. Now, open cloud code the same way we did for the previous build. Open the desktop app. Head into the cloud code panel and this time select the data analysis folder instead of the job tracker. So now the data analysis folder is loaded up inside cloud code completely fresh with just the data set sitting inside it. For permissions keep it on auto mode this time because it's easier when you're moving through an analysis quickly. Now here's where things get interesting. Up to this point in the master class we kept things mostly on Opus 4.7 because we were building a real application. But for the early steps of a data analysis, you don't always need that much horsepower.

51:02 So let's learn how to switch between models intelligently based on what you're actually doing. The first thing you want claude code to do is just understand the data set. Read what's inside, figure out the columns, get a sense of the shape of the data. That's a pretty light task. So let's switch the model down to Haiku 4.5, which is the lightest, easiest model in the lineup. Reading a data set is not rocket science. So Haiku should be enough on paper. So let's say explore the folder and understand the data and let it run.

51:30 And as you can see it's running on haiku 4.5. But look at what happens. The data set is a little too big and haiku tries to load it but runs into trouble. The problem is that the data set is larger than what haiku can comfortably handle in one go. So the run fails. This is one of those moments where you learn the limits of each model in real time and it's actually useful to see it fail rather than just hear about it in theory. So, let's switch back up to Opus 4.7 because Opus comes with a 1 million token context window, which is significantly more headroom than the 200,000 that Haiku has. Now, once you're on Opus, rerun the same prompt. Let's say explore the folder and understand the data. And because the data set is bigger than usual, instead of staying on auto, let's switch the permissions to bypass mode just for this run. So, it doesn't keep stopping you for every small action. Now it's going to extract the archive on its own, read through everything and you don't have to do anything for this stretch and there you go. It has read the entire data set and given you the breakdown of all the columns, demographics, enrollment, activity, purchase behavior and so on.

52:30 This is a classic data set for a lot of analysis problems. Questions like campaign response prediction, customer segmentation and revenue concentration can be answered from this data. So now you actually have to think about what you want to do with it. And this is where most people get stuck because you have the data, you have the tool, but you don't know what questions to ask. So here's a trick you can use. Tell Claude code to think like a data analyst at a top consulting firm. Specifically say, assume you're a data analyst at McKenzie and this is the marketing data set you've been handed. Go through it and tell me if I'm going to walk into a meeting with my CMO, what are the most important questions I need to answer based on this data set. You don't have to think about it on your own. You just chat with claude code the way you'd chat with a smart colleague and it'll come back with the right framing. So it goes through the data set and gives you a list of the questions worth answering.

53:18 And from that list the two big ones that jump out are segmentation and concentration analysis. So now just say run the segmentation and the concentration analysis. So now it's going off and running that analysis for you. And this is the part you really need to pay attention to. whatever packages and libraries are needed to do this analysis. Cloud code figures them out, installs them and runs the analysis on its own. You don't have to know what pandas is. You don't have to know what scikitlearn is. You don't have to know what mattplot liib is. It just handles all of that quietly in the background while it works. If you watch the screen as it runs, it'll mention things like data cleaning, feature engineering, segmentation logic, concentration metrics, and so on. As a non-technical person, you don't really need to understand all of that vocabulary. You can dig deeper if you're curious, but the whole point is that the analysis is being built end to end without you touching a single line of code. So, let's go check the files in the folder while it's working. Open up the project and you'll see a brand new file sitting in there called analysis. py. This is the complete Python script Claude Code wrote to answer the questions you set up. If you open it, you'll see it loading the data, cleaning the data, running the concentration analysis, running the segmentation, generating the charts all stitched together as one neat script. There's also a file called analysis_charts.png, which holds all the visualizations the script generated. And alongside that, you've got the full marketing review breakdown that Cloud Code put together based on the analysis. So now, the next step is to turn this into something you can actually share. tell it. Create a one to two page report with all the graphs and the important information so you can mail it to your CMO. Use the right headings, format it cleanly, and make sure it's readable for a chief marketing officer. And that's it. That's the entire instruction. Claude Code is going to take everything it just generated. Design a clean two-page report and save it as a PDF you can actually attach to an email. You can build your full executive report directly inside Cloud Code. No separate design tool needed. This is the part you'll keep coming back to throughout this master class. Claude code does not mean you need to know coding to solve a problem. You explain what you want clearly and claude code writes the code underneath to solve the problem. The code is just the means, not something you have to learn yourself. Now, while the report is getting built in the background, let's look at another small command that's really handy. It's called /btw, which stands for by the way. It's basically a side chat. You can use it to have a quick conversation with cloud code without breaking the main task it's working on. You saw this briefly when you were running the sub agents earlier.

55:47 But it's worth showing again in this context because it really shines during data work. So type /btw what is this data set about? Because while your report is getting built, you might as well understand the data set in more detail and it comes back instantly with a clean explanation. This is a marketing analytics data set, specifically a food retail style marketing analytics data set. It's built for customer analysis, revenue segmentation, and campaign response prediction. It includes demographics, enrollment date, recency, two-year spend across categories like wine, meat, fish, fruits, sweets, and gold. It also covers purchase channels, web visits, and responses to six different marketing campaigns. So now you have a much clearer picture of what's in the data, and you got it without interrupting the main report generation. That's the value of/BTW. You can run side chats anytime you want without losing the main thread of work.

56:36 Close the side chat and let the report finish in the background. And the bigger lesson here is any data set you want to analyze, any data set you want to go deeper into. You can do that with cloud code in exactly this flow. Drop the data in a folder, frame the question like a real analyst would and let cloud code do the heavy lifting for you. Now, while the report is being built, let's push the analysis even further because the report you're going to get is good, but it can be much better if you layer on a proper data analysis skill on top. So, let's see how to do that. Open a site called skills.sh.

57:07 This is a community-created collection of skills you can install into cloud code for different use cases. So head over there and look for a data analysis skill. And as you can see, there isn't a perfect dedicated data analysis skill on skills.sh at this moment. But there are plenty of other useful skills there and you should keep an eye on it because the library keeps growing pretty quickly. So instead, go to a different source. There's a GitHub repository maintained by the anthropic team themselves called knowledge work plugins. And inside that repo, there's a plug-in specifically built for data analysis work. Now, quick note on what a plug-in actually is because the word gets thrown around a lot. A plug-in is a bundle. It's a collection of skills, agents, and commands packaged together all designed to handle one particular type of work end to end. So, instead of installing a single skill, you're installing a whole toolkit at once. So, pull up the plug-in and tell Claude Code, install this skill locally and point it to the data analysis plug-in. It'll ask you to trust the source before installing, which makes sense because you're pulling code from an external repository. Click trust and it'll go through the install process in the background while you do other things. While that's installing, let's actually go and check the CMO report that Claude Code finished building a minute ago. Open the folder and look at this. The CMO marketing report is sitting right there. Open it up and you can see what it produced. It opens with the customer marketing review header.

58:33 Then it goes into revenue concentration with a clean parto style breakdown. Then customer segmentation with three data validated segments laid out clearly. And then a recommended action section at the end which is exactly what a CMO would want to walk away with after a meeting like this. So you already have a presentable properly formatted report from the first pass. Now let's see what happens when you layer the new skills on top of that same workflow. The data analysis plug-in is fully installed now.

59:02 So tell cloud code use the available skills, pick the right ones for the job, redo the analysis and recreate the CMO on one pager for you. And along with that let's introduce one more thing in this run. There's an MCP server called context 7 that you'll plug in here. So say use the context 7 MCP server to write good Python code for the analysis. Quick explanation on what Context 7 is because this is genuinely useful and you should know about it. Context 7 is an MCP server that has up-to-date documentation for pretty much every major library out there. So if you're writing Python code and you need to use pandas or scikitlearn or mattplot liib or any of the standard data analysis libraries, context 7 can pull the latest documentation for that library directly into the workflow. Which means the code claude code writes is not based on what it remembers from training. It's based on the actual current version of the library you're using right now. So if you're working on data exploration and want to use scikitlearn which is the standard library for any kind of machine learning task, context 7 makes sure you have the latest scikitlearn documentation feeding into cloud code.

60:11 Same goes for any other library you bring in. you get the best available library fully upto-date with all the information the model needs to write clean code that actually works. So now claude code is doing two things in parallel. It's running the new data analysis skills you just installed and it's pulling fresh library documentation through context 7 to make sure the Python code it writes is using the latest and best approach. You can watch it work through the to-do list, ticking off steps like statistical analysis, then data visualization, then segmentation refinement, all in sequence. It's checking each step against the skills, pulling documentation through context 7 and running the analysis as it goes. And again, all the technical details flying across the screen. As a non-technical person, you don't need to worry about any of it. The whole thing is running on its own. So the redone analysis is finished. And now let's go and check the new report. Open the folder again. Pull up the latest version of the CMO report.

61:10 And look at this side by side with the earlier one. The graphs are visibly better. The data is more thoroughly built out. The segments are crisper. The recommendations are sharper. The whole report is in a different league compared to the first pass you saw a few minutes ago. And just like that, with the addition of a couple of skills and one MCP server, you've taken a basic data analysis report and turned it into something genuinely sharp. That's the entire point. You don't have to be a data analyst to produce a CMO ready report. You just have to know how to stack the right skills and the right MCP on top of cloud code and let it elevate this complete report for you. So that was how to do data analysis. That brings us to build number three. A fully researched pitch deck that can be presented to investors. It will contain real market data, a competitive analysis, and will be entirely designed and usable. Now, design, as we know, is not a problem for AI to execute, but getting the right research in place is a challenge. So, we're going to see how cloud code handles it for us. Let's open a fresh project. First, switch the model to Opus 4.7. Since we're pulling a lot more information this time, we want this model solid reasoning capabilities.

62:23 Before writing a single prompt, we need to set up an external research partner who will handle bringing real market data, competitor information, and verified numbers. Claude code on its own can't fetch live information from the web. So, we connect it to a tool that can. That tool is parallel search. Let's head to parallel.ai. They benchmark directly against Perplexity and OpenAI. And you can see client case studies if you scroll down. The best part, they have a completely free MCP server you can install into cloud code. No sign up or API keys are needed. Just follow their setup guide and copy paste the ready-made settings to get it working across iPhone, Android, web, and more in minutes. We've already installed the Parallel Search MCP. So now let's write the first prompt. Use parallel search to do research and market analysis for an AI product that can scrape and find leads for a particular business vertical. I've built a lead generation tool as a side project and I want full market research to pitch to investors.

63:25 As you hit enter, Claude Code starts the session. First thing it does is it runs a tool search to figure out what's available. It finds the parallel MCP. Then watch this. It doesn't blindly start. It stops and asks clarifying questions. Which business vertical B2B SAS and tech, real estate, local services, or recruiting and staffing? Let's pick B2B SAS and tech we're building for software companies selling to other software companies. Then it asks about the angle of research. Let's check competitive landscape, market size, and growth. Now click on submit.

63:58 Look at the screen. Claude code is spinning off multiple parallel searches at once. One on market size and growth. Building a structured table with segment value for 2024 to 2025. Forecast figures CAGR source citations. Another mapping the competitive landscape across four tiers. A third pulling recent funding and category trends. Days of manual research would have gone in this but now it's done in 5 minutes. Now let's turn this research into a presentation. So first let's ask Claude to do more research and figure out an eight slide structure so we can present this opportunity to seed VCs and pitch the idea. Claude code kicks off a second wave of parallel research. Now it fills the VC pitch gaps, the pain points, unit economics and category benchmarks. It pulls this information from sites like Crunchb and G2 behind the scenes and there's an MCP working underneath taking each angle and giving the data back.

64:55 When it's done, you get the full eight slide outline from the hook, problem, why now, the insight to the product, numbers, and ask. That's a start. But now, let's push it further. Let's tell Claude Code, research the best pitch deck, color palette, typography, and storytelling frameworks so we can design the deck properly. As usual, Claude Code spins up multiple parallel search instances, each piece of the prompt running at once. It researches what makes a great investor presentation from the best colors, fonts, and storytelling style. It studies everything at once and recommends a clean, professional design, one idea per slide, and a story structure where it uses the rule of three. Three problems, three signals, three numbers. Now, the pitch should feel like a compelling story instead of random slides. Now, let's tell Claude to rebuild the eight slide deck around the problem agitate solution framework while keeping the exact same design rules we just researched. Let's give it a second to work. Now, let's add a few more details. Let's set the ask amount to $2 million. We also need a product name.

66:00 The final format should be in PPTX. And let's make it clear that this is a side pitch, not related to any real company. A few name options come back. I had Glint in mind before we even started. So let's quickly check whether it's already taken. We ask Claude to check if there's already a SAS product named Glint and if there is to suggest better alternatives. It comes back with names like Lacuna along with Pith Brim and Augur. This is an iterative process so let's be patient. Claude Code spins up another parallel search, scans the software market, checks naming conflicts and comes back with an answer. Glint is already heavily used especially in LinkedIn employee engagement tools.

66:35 Claude recommends Lakuna instead. Clean, available, no major conflicts. Okay, let's lock that now. Let's build the PPTX. Claude already has a PPTX skill built directly into the workflow. The skill activates and starts assembling the deck. You'll see a permission dialogue asking whether Claude can edit PPTX files. Allow it. You can switch from auto to always allow and then move into auto mode for the rest of the build. Quick warning here, don't jump straight into auto mode. It's powerful but risky. Start in manual mode. Watch what Claude is doing. Understand the workflow and move to auto once you're comfortable. Underneath, Claude is also running visual quality checks on every slide. It renders the slide, check spacing and layout, confirms everything looks right and only then moves to the next one. Then comes another permission dialogue allowing Claude to control Keynote or PowerPoint for previews. Hit allow. And then finally, the line we've been waiting for, deck shipped, and the file has been generated. A summary of the deck structure appears on screen, confirming that every single slide has been built. Now comes the moment of truth. Let's switch to Comet, open Google Drive, click file upload, and import our PPT from the downloads folder into Google Slides. Now, let's walk through this exactly as if there's an investor sitting across the table. Slide one is around the problem. 72% of a B2B SAS reps day isn't spent selling. It's a sharp statistic, simple, surprising, and powerful enough to immediately get an investor leaning in. Slide two says, "The lead generation stack is broken.

68:06 Companies are spending 96,000 to $144,000 a year on sales tools, yet reps struggle to find buyers who are actually ready to purchase. The problem is not that reps are lazy. The problem is that the tools are broken. They don't tell you who is actually buying." Slide three is the agitation and this is where we get some examples. Take Apollo, a tool built to help sales teams find prospects and automate outbound outreach. It has a 2.9 trust pilot rating, 15 to 35% email bounce rates, confusing pricing, and Reddit threads filled with complaints that the data quality has dropped. Then there's Clay, a platform designed to enrich sales data, and build smarter prospecting workflows. At nearly $800 a month, it quickly becomes difficult to justify at scale. And then you have Artisan, an AI platform built to automate sales outreach altogether. The idea is simple. Let AI find prospects, send emails, follow up, and book meetings automatically. But at roughly $36,000 a year, it is expensive. And its faster outreach can quickly turn into spam instead of meaningful sales conversations. On top of that, it is mostly sold through enterprise plans, making it harder for smaller teams to access. The takeaway is simple. More outreach does not mean better outreach.

69:29 Everyone is helping sales teams reach more people faster, but very few tools help them find the people who are actually ready to buy. Then we go to slide four, which is why now. Here it says three major shifts are happening at the same time. More sales teams are adopting AI, buying signals and customer data are becoming real time and go to market engineering has grown into a serious category of its own. In simple terms, the way companies sell is changing and moments like this create openings for entirely new products. It is a moment similar to what happened when CRM software changed sales in the mid200s and this is where Lacuna is positioning itself. Then there's slide five, the wedge. Most companies in the space picked one side. They either focused on building better lead lists or finding better buying signals. Lacuna is trying to combine both. You get a simple 2x two matrix that shows why this matters. The idea is to build something competitors cannot easily copy just by adding more data. And that empty space on the chart that is exactly where Lakuna wants to go. Slide six is the product. Three layers working together to deliver one outcome. There's complicated terminologies, but they basically mean that the first layer identifies the right type of customer.

70:47 The second layer understands who is actually likely to buy and third is designed to reach them at the right moment. Put together, the goal is simple. Help sales teams book meetings with people who are genuinely ready to buy. Slide seven shows us the numbers. A 15.55 billion market, a 9-month payback period, and a cost that is 20 times lower. This is the part that explains why the business model can work at scale and why investors should care. Finally, slide eight is the ask. The company is raising $2 million in seed funding to move fast and capture this opportunity before larger competitors catch on. And that is the complete eight slide pitch deck. It's a very thorough starting point. Now, just step back and look at what we pulled off. We didn't write a single line of code. We didn't open Google to do the research. We didn't touch PowerPoint or Keynote. Everything from the research to the storytelling to the product naming to the final designed file handled by claude code with one free MCP server and one built-in skill.

71:48 Now before you go and build any of this yourself, there is one more thing you have to see because it makes everything we just did even faster. Right after recording this masterass, Claude quietly dropped a brand new model. It's called Opus 4.8 and it is a real step up from the 4.7 we've been using this whole video. noticeably sharper at coding and reasoning and a lot better at catching its own mistakes, which is something you're going to watch it do live in just a minute. And it came with a whole set of new features. Let's explore them. The moment you open the model menu inside Cloud Code, you can see 4.8 sitting right there, including a version with a full 1 million context, which just means it can hold a huge amount of information in its head at once before it starts forgetting things. Right below that, look at the setting called effort. You can pick between low, medium, high, extra, or max. The simple way to think about it is how hard you want the model to think before it answers you. Low is quick and cheap. Max is slow and thorough. And right next to it, there's a fast mode, which can run Opus around two and a half times faster than normal, and it works out roughly three times cheaper than the previous fast mode pricing. But the feature you really want to see here is called dynamic workflows.

73:04 You can activate it using the new command called /workflow. When you type it in, it researches and plans a large task and then runs multiple sub aents to complete the task. Let's break it down simply. A sub aent is basically a smaller version of Claude that goes off and handles one job on its own. Normally, you talk to one Claude. One prompt, one answer, you wait, you prompt again. With workflows, Claude can spin up a whole team of these sub agents and put them all to work at the same time.

73:35 Think of it like the difference between asking a single assistant to do everything versus running a full team where each person owns one piece and they all move together. Anthropic built this for the really big problems where you'd normally be stuck for days. Let's walk you through a small example so you can see what this looks like for real content work. The prompt we're giving is audit my YouTube channel from the last 3 months and give me 10 content ideas. We paste the channel link, tell it to use /workflow, and finally pick opus 4.8 high mode with 1 million context. Now, the first workflow it launched, it failed. Claude realized it didn't have the real channel data yet. So, it stopped itself, wrote its own Python script to go pull the actual numbers and kicked off a fresh workflow called vit- audit-v2.

74:24 It caught its own mistake and fixed it. Then, keep your eye on the right side of the screen. It opens with three agents. Three quickly turns into more. By the end, there are 18 agents running in the background all at once, and they're sorted into three clean phases. First, it audits the channel. Then, it ideates on fresh angles. Then it scores every single idea. One agent is pulling breakout data from Vid IQ. Another is reading the actual comments sitting under the top videos. Another is checking what people are even typing into search. 18 agents, 1.1 million tokens. It's burnt more tokens than a normal chat for sure. But just look at what happened in that window. It did the work of an entire research team start to finish in one go while you just sit back and watch it happen. And the output is not some vague little summary. Right at the top, it tells you exactly how it was built from VidQ data, comments, and keyword searches. Then it runs through a panel of agents that stress test every single idea before it makes the cut.

75:25 From there, it hands you 10 content ideas that are ranked by how much real demand there is for each one and how well each one actually fits the channel. Infosys and TCS just replaced freshers with AL agents. Do this now or lose your IT job ranks 26 out of 30 and nine more ideas like this. Right under that, it lays out three strategic shifts we need to make on the channel, like rationing our AI updates videos, and then it does the thing you'd actually want a strategist to do. It tells you the one idea we should ship first, but before it builds that idea out, it shows you the active learnings from this session.

76:04 Basically, what it picked up about the channel along the way. So, it isn't running some generic YouTube playbook on you. It's running the rules of this specific channel pulled straight from what's actually worked before. Then, it builds the full package around that first idea, the one it's calling the AI avatar reveal. Under that, you get a whole stack of title options to pick from, a recommended A/B test and its backup, a note on how the thumbnail should line up with that title, and then a full thumbnail brief with three different concepts to test against each other. And it doesn't stop at the visuals. It writes you the hook options for the first 30 seconds, too, which is the part that decides whether anyone sticks around at all. And right at the bottom, it leaves you with a clear plan for what to do next. Write the full script, run it through the CTA protocol, prep the editing brief, then go test it.

76:52 So, you don't walk away with a nice idea and no clue where to start. You walk away with the exact next steps already mapped out in front of you. So, Claude Code has basically stopped being just a coding tool. This is a research tool as well. Now, one prompt goes in, a fully researched content strategy comes out, and that is exactly how I'm planning to use this going forward. And that's a wrap on the complete Claude code masterass. If you take only one thing away from this video, take this. The hardest part of building software is no longer the building. It's deciding what to build. The tools are right here waiting for you. Now, go make something.

77:25 In fact, drop a comment below telling me what you're going to build with Cloud Code. I read every single one of them. And if you want more master classes like this one, subscribe so the next one shows up in your feed automatically. If you like this video and want to explore more tools by Claude, I've made a mastery guide on how to use Claude Co-work. I'm attaching the video on screen so you can check it out. That's it for today. I'll see you in the next one.