YouTube Deep SummaryYouTube Deep Summary

Star Extract content that makes a tangible impact on your life

Video thumbnail

I Went Deep on Claude Code—These Are My Top 13 Tricks

Matt Maher • 26:08 minutes • Published 2025-07-07 • YouTube

📚 Chapter Summaries (16)

🤖 AI-Generated Summary:

📚 Video Chapters (16 chapters):

📹 Video Information:

Title: I Went Deep on Claude Code—These Are My Top 13 Tricks
Duration: 26:08

Overview

This video is a comprehensive, tip-driven walkthrough of advanced Claude Code usage, focusing on maximizing productivity, customization, and automation for developers. Across 16 clearly delineated chapters, the creator begins with foundational setup steps and basic usage, then builds to advanced features like custom commands, sub-agents, utility scripting, and workflow automation using hooks. The chapters are structured to progressively deepen understanding, with each new section building on concepts and capabilities introduced earlier, providing a step-by-step learning journey from installation to power-user strategies.


Chapter-by-Chapter Deep Dive

Intro (00:00)

  • Core Concepts: Introduces Claude Code as a powerful daily tool, teasing that a blend of simple and advanced tricks can make it delightful and efficient.
  • Key Insights: Some tips are basic, but others are novel or less known; even seasoned users might learn something new, especially toward the end.
  • Actionable Advice: If overwhelmed, reference a previous more basic video or ask ChatGPT; skip ahead if early chapters feel familiar, as later tips are more advanced.
  • Connection: Sets the tone for a fast-paced, tip-rich session, emphasizing that the value of these tips compounds over time.

Fast Install (01:53)

  • Core Concepts: Quick start guide for installing Claude Code.
  • Key Insights: Installation is as simple as running a terminal command found via a web search.
  • Actionable Advice: Always launch Claude Code from a project-specific folder rather than a generic or root directory to avoid confusion and maintain organization.
  • Connection: Lays the necessary groundwork for using Claude Code effectively in real projects.

1. Use in Cursor or VSC (02:33)

  • Core Concepts: Using Claude Code inside modern IDEs like Cursor or Visual Studio Code (VSC).
  • Key Insights: IDE integration grants superior control—viewing and referencing files is much easier, and commands are context-aware.
  • Actionable Advice: Use the /ide slash command to manage and confirm IDE integration so Claude Code recognizes your open files and context.
  • Connection: Prepares users for richer, more interactive workflows by leveraging IDE features.

2. Initialize Project (03:39)

  • Core Concepts: Initializing a Claude Code project with the /init command.
  • Key Insights: The command generates a claude.md memory file summarizing the project’s structure and context, which is referenced in every new chat.
  • Actionable Advice: Always run /init at the start of a new project to ensure proper context and memory for all future Claude Code interactions.
  • Connection: Ensures that all future tips and features work with a well-defined project context.

3. Manage Context (04:26)

  • Core Concepts: Handling chat and workspace context, including summarization and clearing.
  • Key Insights: Large project histories can bloat the context window; Claude Code summarizes (compacts) context to keep interactions relevant and within model limits.
  • Actionable Advice: Use /compact to manually summarize long chats, and /clear to reset the conversation while retaining project context from claude.md; compacting takes time, so plan accordingly.
  • Connection: Teaches context management fundamentals, enabling advanced, ongoing usage without context overflow.

4. Change Models (06:12)

  • Core Concepts: Switching between Claude model variants (e.g., Opus and Sonnet).
  • Key Insights: Model switching allows balancing power and resource limits, especially for users with Anthropic subscriptions.
  • Actionable Advice: Select the appropriate model based on your needs and subscription status; understand how the default setting balances usage.
  • Connection: Introduces model flexibility, a key lever for performance and quota management.

5. Change Modes (w/ planning) (06:42)

  • Core Concepts: Switching operation modes (default, auto accept, plan) using Shift+Tab.
  • Key Insights: Modes affect file-writing permissions and approval prompts; "plan" mode is especially useful for generating and refining work plans before action.
  • Actionable Advice: Use "auto accept" for quicker workflows, and "plan" mode for collaborative plan-building—read and iterate on plans before approving.
  • Connection: Adds granularity and safety to interactions, setting up for more complex features.

6. Add Files and Screenshots (07:45)

  • Core Concepts: Adding files or screenshots to Claude Code sessions.
  • Key Insights: Files can be referenced by path or with an @ command; screenshots can be dragged in and are handled as file paths. Clipboard integration allows fast pasting (ctrl+V in terminal).
  • Actionable Advice: Use image and file inputs liberally—Claude Code processes visual data extremely well for debugging and context-sharing.
  • Connection: Expands the types of data Claude Code can handle, foreshadowing later automation and utility features.

7. Terminal Tab (09:33)

  • Core Concepts: Using Claude Code in a terminal tab.
  • Key Insights: Command-escape opens Claude in a new tab, functioning like any other IDE tab, enhancing multitasking.
  • Actionable Advice: Leverage tabbed Claude Code sessions for parallel workflows.
  • Connection: Sets up advanced use cases involving multi-tab and multitasking operations.

8. Custom Commands (10:00)

  • Core Concepts: Creating and managing custom slash commands.
  • Key Insights: Custom commands are markdown files in .claude/commands, allowing team sharing via version control; available globally if placed in the home directory.
  • Actionable Advice: Build reusable prompts and workflows as markdown command files, organize them for team/project/global use, and use arguments for dynamic input.
  • Connection: Introduces automation and customization, a foundation for personalized and team-wide productivity boosts.

9. Coloring Cursor Command (12:44)

  • Core Concepts: Customizing workspace appearance (e.g., coloring projects in VSC) using Claude Code.
  • Key Insights: Claude Code can generate and apply settings (like color themes) programmatically, both per project and system-wide.
  • Actionable Advice: Create project-level or global commands/settings for consistent, visually-distinct environments—useful for context switching.
  • Connection: Demonstrates practical use of custom commands for environment personalization.

10. Sub-agents: Multi-tasking! (14:39)

  • Core Concepts: Using sub-agents for parallel task execution (e.g., generating multiple UI designs at once).
  • Key Insights: Claude Code can run concurrent, headless subtasks and aggregate results (e.g., five UI design variations processed in parallel).
  • Actionable Advice: Use sub-agent features for iterative or batch tasks—define the number of subtasks and automate creative/functional experimentation.
  • Connection: Moves from single-threaded to multi-threaded AI workflows, opening the door to powerful parallelization.

11. YOLO (17:32)

  • Core Concepts: Running Claude Code with permission checks bypassed.
  • Key Insights: Skipping permissions can dramatically speed up workflows but is risky—potential for unintended file changes.
  • Actionable Advice: Only use the "YOLO" mode (dangerously skip permissions) if you fully trust your environment and understand the risks; set up personal safeguards.
  • Connection: Provides a power-user shortcut with a strong caution—automation vs. safety trade-off.

12. Claude as a Utility Function (18:24)

  • Core Concepts: Integrating Claude Code into system utilities and scripts (e.g., via Raycast).
  • Key Insights: Scripts can call Claude Code for intelligent file processing, such as converting clipboard text to files with appropriate names/extensions, then auto-saving and re-copying.
  • Actionable Advice: Leverage CLI and scripting integration for advanced automation—use Claude Code as a utility function in broader workflows.
  • Connection: Expands Claude Code's reach beyond the IDE, showing its value as a general-purpose AI utility.

13. Hooks! (20:53)

  • Core Concepts: Automating post-task actions with "hooks" (event-driven scripts) at both global and project levels.
  • Key Insights: Five hook types allow actions before/after tool use, notifications, and sub-agent/task completion; can trigger audio cues or other responses.
  • Actionable Advice: Define hooks in project or global settings to trigger notifications, sounds, or scripts upon task completion—great for tracking asynchronous or long-running jobs.
  • Connection: Culminates the automation journey, making workflows responsive and self-managing.

Closing (24:52)

  • Core Concepts: Recap and encouragement to experiment further with Claude Code enhancements.
  • Key Insights: The presented tips are a starting point; combining them unlocks even greater productivity and creativity.
  • Actionable Advice: Try out combinations, subscribe for more content, and engage (comment/subscribe) for feedback and future deep-dives.
  • Connection: Reinforces the value of cumulative learning and experimentation, inviting viewers to take the next steps.

Cross-Chapter Synthesis

Recurring Themes & Progressive Learning

  • Customization: From project initialization (Ch.2) to custom commands (Ch.8–9) and hooks (Ch.13), the video emphasizes tailoring Claude Code to your needs.
  • Context Management: Chapters 2–4 establish the importance of maintaining, summarizing, and resetting context for effective AI interactions.
  • Workflow Automation: Custom commands (Ch.8–9), sub-agents (Ch.10), utility scripting (Ch.12), and hooks (Ch.13) form a progression from manual tips to full automation.
  • Safety vs. Power: The YOLO chapter (Ch.11) exemplifies the trade-off between speed/automation and risk, a theme echoed in context and mode management (Ch.3, Ch.5).
  • Multimodal & Multitasking: File/image inputs (Ch.6) and sub-agents (Ch.10) show how to leverage Claude Code for richer, parallel workflows.
  • Integration: IDE integration (Ch.1), system scripts (Ch.12), and hooks (Ch.13) showcase how Claude Code fits into a broader developer toolchain.

The Learning Journey

The video starts with basic setup and context management, ensuring viewers have a strong foundation. It then introduces progressively more advanced features, culminating in automation and integration strategies that transform Claude Code from a simple assistant into a powerful, customizable, and automated development platform.

Most Important Points Across Chapters

  • Project Initialization & Context (Ch.2–3): Always start with /init and manage context actively.
  • IDE Integration (Ch.1): Use Claude Code in Cursor/VSC for maximal productivity.
  • Custom Commands & Settings (Ch.8–9): Create reusable workflows for yourself and your team.
  • Parallelization & Automation (Ch.10, Ch.13): Employ sub-agents and hooks for multitasking and responsiveness.
  • Caution with Automation (Ch.11): Know when to trade safety for speed, and always set safeguards.

Actionable Strategies by Chapter

Fast Install (Ch.2)
- Search for Claude Code, copy the install command, run in your terminal
- Always run Claude in a project folder

Use in Cursor or VSC (Ch.3)
- Open Claude Code inside Cursor/VSC for file awareness
- Use /ide to confirm and manage IDE integration

Initialize Project (Ch.4)
- Use /init to create project context (claude.md)

Manage Context (Ch.5)
- Use /compact to summarize long conversations
- Use /clear to reset context while retaining project memory

Change Models (Ch.6)
- Switch models as needed based on task/resource (Opus vs. Sonnet)

Change Modes (w/ planning) (Ch.7)
- Use Shift+Tab to toggle between modes for planning or auto-acceptance
- Review and iterate on plans in "plan" mode

Add Files and Screenshots (Ch.8)
- Drag files/screenshots into Claude
- Use @filename for references, ctrl+V for clipboard images

Terminal Tab (Ch.9)
- Use command-escape to open Claude in a new tab for multitasking

Custom Commands (Ch.10)
- Create .claude/commands/*.md files for custom slash commands
- Organize commands at project or global (~/.claude) level

Coloring Cursor Command (Ch.11)
- Use project/global settings to customize IDE appearance with Claude

Sub-agents: Multi-tasking! (Ch.12)
- Use sub-agents for parallel tasks (e.g., design iterations)

YOLO (Ch.13)
- Use permission-skipping mode for trusted, fast workflows (with caution)

Claude as a Utility Function (Ch.14)
- Integrate Claude into scripts (e.g., via Raycast) for advanced automation

Hooks! (Ch.15)
- Set up hooks in project/global settings to trigger actions on task completion (e.g., custom sounds, notifications)

Closing (Ch.16)
- Experiment with combining tips; engage with the community for more


Warnings & Pitfalls

  • YOLO Mode (Ch.11): Skipping permissions is powerful but risky; only use in safe, controlled environments and at your own risk.
  • Context Compaction (Ch.5): Compacting can be time-consuming—plan accordingly.
  • Clipboard/Drag-and-Drop (Ch.8): Terminal input method for images is unintuitive (ctrl+V vs. cmd+V on Mac)—pay attention to application quirks.

Resources, Tools, & Next Steps

  • Project Files: .claude/commands, .claude/settings, .claude.md (project memory file)
  • IDE Support: Cursor, Visual Studio Code (VSC)
  • Scripting Tools: Raycast (for Mac), AF play (audio notifications)
  • Further Learning: Previous basic video on Claude Code, comments/subscription for feedback and requests

This summary leverages the chapter structure to provide both sequential and holistic understanding, guiding users from setup through to advanced, automated, and integrated workflows in Claude Code.


📝 Transcript Chapters (16 chapters):

📝 Transcript (766 entries):

## Intro [00:00] [00:00] Clawed code is already super powerful [00:03] and I use it every day. But with just a few of these tricks, I've turned it into something that I actually truly enjoy using. Two fish are in a tank. One turns to the other and says, "Do you know how to drive this thing?" Gosh, I just wish [00:16] that I could get this more easily done [00:18] inside of cursor. Oh, good lord. I mean, I asked for crazy. Wow. Yes. Yes. I [00:24] didn't tell you about it. Today, I'm going to cover 11 of my favorite tips and tricks. Some of them are very obvious and I'll fly right through them very quickly, but others are kind of brand new or really interesting to see. And one of them really makes it just really delightful to work in clawed code. And I hope you think so, too. But [00:43] admittedly, I like to be a little bit [00:44] silly sometimes. But we really have to push forward. So, this will be a little bit quick. If you get lost anywhere, I have a previous video about claude code in general. If you don't know about [00:54] claude code, you can go check that [00:57] previous video out. and maybe that'll give you a little bit more information or just ask chat GPT about some of these things. All right, let's dive in real quick. Oh, one note before we get started. A lot of this is going to get [01:08] compressed and it's going to feel pretty [01:09] tight and fast. It's not intended to be that fast. Let me know. Send me a comment or something like that if you need me to make a whole video about any one of these or share something that I didn't share. But at the same time, it [01:21] also got a little bit long. I have so much to share that really makes a different with with the way that I use clawed code and it really makes it very valuable to me that I really wanted to share them all. That's why it got a little bit longer. So I have to apologize upfront taking even more time to just do that which is insane. But I [01:38] apologize for the length I think toward [01:40] the end. If you see the first ones and you feel like I've seen all this, you won't have seen all the ones toward the end. So I would say just skip forward or wait until those come up because these really compound quite nicely. All right, let's jump into the real content. All ## Fast Install [01:53] [01:53] right, this is not number one, but [01:55] installing Claude Code. You'll have to go to Claude Code. Just search for it and take this command to install. Take it to a terminal and install it in your terminal right there and you'll be on your way. So, that's how you get Claude [02:07] Code started installed. Once you have it installed, you can just type in Claude and you'll open Claude Code in the folder that you're in. I wanted to show you this. I opened this in my root folder and Claude Code now comes up. It [02:20] didn't do this in the past, but it comes [02:21] up and say, "Oh, are you sure you want [02:23] to open this in this folder?" What you really want to do is open claude code in a project folder where you're writing code. So, just create a brand new folder if you need to and do the same thing. Just type in claude. Nice and easy. ## 1. Use in Cursor or VSC [02:33] [02:33] Okay, the first tip, open claude code in [02:36] cursor or Visual Studio Code. Both of those are free applications to just install and use. You don't have to be a subscriber VSC if you're not a cursor user at all. What we're really trying to do is have some of the controls like being able to see files and be able to see the contents very easily. So we're [02:52] going to be inside of cursor here. I will pull open a terminal just like we were in a terminal window before. Once you're inside of cursor and you've run claude. So here we are looking at claude. I'm going to run a slash command [03:04] and there is a slash command called IDE. And you can see here that it says manage IDE integrations and show your status. So if I hit that it knows that I'm in cursor and what that really does is if I happen to open a file then what will happen is when I come down here it will gain reference to the file that I have open because of that integration. So that's one of the things that's one of our first tricks is once you do this you'll be working within the IDE and files that you have and things that you select will show up down below or inside of the terminal version of claude when you're using it and it allows both of them to work together. We got to move ## 2. Initialize Project [03:39] [03:39] on. All right, for the next one, very easy one. It's /init. And it's really the way that you get started inside of Claude Code in a new project. So, what [03:47] it's about to do when I hit init is [03:49] it'll look through the entire project [03:51] and tell me something about the project [03:53] and record it all in this special file [03:55] called claude MD. It's just a file that lists all the directories and all the opinions of the system. This is what they call their memory file. And this is kind of a thing that's pumped into the beginning of every chat that you start. [04:08] It basically preeds all of the chats [04:11] that you start just once so that every [04:13] chat you have has this information [04:15] inside of it and contextually the models [04:17] underneath will always kind of have an [04:19] idea of what project it's working inside [04:21] of. So basically new project start get started and then run clot you can do it ## 3. Manage Context [04:26] [04:26] at any time. Okay, so the next one, in fact, two really fast I'm going to show you because you know these already. You've probably heard about them as you move in. Think chat GBT. You start a new [04:36] chat, you have a conversation, it gets [04:37] longer and longer. All of that is within the context is the idea. So all of this gets sent back and forth sort of to the model every single time. The model has all of that information to continue to work on and it helps kind of get better about the conversation as it goes forward. Same thing happens here except [04:54] there's a lot more data sometimes in a [04:55] project, right? these projects get really really big and the context window is pretty big these days. So everything inside of this this context is piled on top of everything. What you'll start seeing is a message down here saying 25% until compaction or something like that. [05:11] What it's trying to say is I can't have [05:13] an endless amount of information going [05:15] in. So I have to summarize it to some degree and keep the nuances so that the next question in this chat that you have I'll still remember all the other things that we were talking about. So that one is compact and you can run that yourself and you'll see it's clears conversation history but keeps a summary. So that one's important. You can run compact [05:33] anytime you're kind of working through a [05:35] problem continually and you want smaller [05:37] and smaller essentially contexts for the [05:40] model to kind of work on instead of [05:42] having this enormous history. It will autoco compact. It takes a while to compact. So do it when you feel like you have time to do it if you're going to compact. But the one that I would advise [05:50] is actually clear. So, it's a sister to the compact and it's really the first one that you need to learn. It's basically hitting the new button or the plus button in chat GPT to create a new chat. This one just clears everything out, starts a new conversation history, by the way, shves that Claude MD file in there so that Claude kind of understands those those things again, and then you're off to the races with a new ## 4. Change Models [06:12] [06:12] context. Okay, some later ones get better. I know you've probably heard quite a few of these, but I thought they were important to put in here just in case some people hadn't. The next one I'm going to show is you can change the model that you're on. If you have a [06:24] subscription with an anthropic that [06:25] allows you to have both Opus and Sonnet. This is the way that you can choose between Opus and Sonnet or you can choose their default which does Opus 4 as the first model all the time up to 50% of your usage and then it starts using Sonnet for when it thinks oh you might be getting close. Let me pull back a little bit. The other one here just ## 5. Change Modes (w/ planning) [06:42] [06:43] going to rush through this. If you hit shift tab, you'll see that this is flashing at the bottom of the screen here as I'm continuing to hit shift tab. So, it starts on this mode, no mode at all. Let's call it default mode. And [06:54] then if you shift tab one time, it goes [06:56] into auto accept. And that really is every now and then when you ask it to do something, if it's going to write a file, if it's going to list your files, read your files, change a directory, those kinds of things, it will come back and say, is it okay that I do this? Yes, no, yes every time within this session. Don't ask me again. Those are the kinds [07:11] of things that you'll see here. This mode kind of auto accepts many of those, not all of them. You will still get that question. Plan mode though is just for conversational. It won't write any [07:21] files. The idea is you ask it to plan something out. It comes back with a huge well-th thoughtout plan. Asks you if you're okay with it. I would advise [07:29] reading through that plan and saying no [07:31] and having more conversation with it. It will end up with a very good plan. If you work back and forth with it a bit and then you can say yes, and it will go off to the races and start doing its thing. shift tab into auto accept and you'll have a much better time. But [07:43] that's not the only way to do this. ## 6. Add Files and Screenshots [07:45] [07:45] Okay, here's another. I'm gonna try to be brief about this one, but this one is critically useful to me. So, I want you to hear you can put files into this. Now, admittedly, we're inside of the uh cursor environment at this point, so it gets a little confusing, but I can drag this file over here. And if I drop that [08:01] file there, you'll see that it puts in [08:04] the path essentially to that file. That's one way so that you can reference files directly with a path name and that works. But you can also use the at command to get to that. So if I wanted to get to the calculator file, that's how I would reference it with an at. So [08:18] tab completed that. It just selected what I was on. So that's an easy way to kind of reference files that are within your project. The other thing that's actually quite useful is if you take a screenshot of something. So that takes a [08:29] screenshot. I have a little utility down here that allows me to drag my screenshot around. And if I put it there, you'll notice all it's really doing is putting the path in to the screenshot, which is kind of nice. So that's just referencing the file that we created underneath this. And there's [08:44] another way, and I'll have to show you [08:45] an interesting utility that I have [08:47] called paste, which is this is my [08:49] clipboard. This is the clipboard that I've things that I've clipped recently. And what happened when I took that screenshot, they automatically go into my clipboard as well. I can drag it from here or I can just paste it here. And [09:00] this is not obvious. So this is the one that's worth talking about. control V. Now in Mac, all Mac users will kind of hear that and go, "Yeah, yeah, command V." They meant command V. I really meant [09:09] controlV. So weirdly in in this terminal application of clawed code. If you use controlV, it'll just paste right in. So this is essentially the same image. [09:17] That's the trick. I highly highly advise sending images in. It is a fantastic way to work. These models can figure out a whole bunch. I could just take a whole [09:26] picture of this this entire system and [09:28] say, "Oh, go figure out what's wrong." And it does a very good job of figuring that out. All right, moving on. Okay, a ## 7. Terminal Tab [09:33] [09:33] quick side trick. So, I haven't talked about this yet. Let me exit this terminal version of Claude. We'll close that window down. There happens to be a [09:41] command escape mechanism that I can open [09:44] up a clawed tab. So, it works more like a tab than it does that parked terminal window. Interesting, but it's just shell running in the tab. I'm going to run this way. I just wanted to show you [09:52] that. And I really like command escape to be able to pull open claw at any time. And then I can just treat it like any other tab. Okay. So, with that, ## 8. Custom Commands [10:00] [10:00] we're going to need to talk about custom [10:01] commands. Now, these commands are these slash commands. We've seen them before, and you can see that I have a couple extra commands at the top, including the normal ones that Claude will give you. So, let's talk about these extra ones at the top. I have one called joke me. Tell [10:15] me a dad joke. And if I hit enter, it executes that command right away. Goes to the model. The model runs the execution. And then whatever comes back [10:24] is what it presents to us. Why don't scientists trust atoms? I think you know the answer to that. Okay. So very [10:29] quickly, where did this come from? What is that all about? All right. So if you look into the files over here, it's one of the reasons that it's neat to be inside of cursor or some other system that you can kind of just directly edit files. I have created a do.cloud folder. [10:43] I just created all this by hand. So just feel free to create. Then there's inside of that. Cloud folder another folder called commands. This is just the file [10:50] structure that cla code uses to hold [10:52] these things. And then inside of that is a markdown file. any markdown file that it finds inside of the commands folder, it will use as a custom command. And you can put them in subfolders, a whole bunch of other things. Go look it up. [11:05] But if we look inside of joke me, this [11:07] file that I've created, tell me a dad [11:09] joke is what shows up when I hit the [11:11] slash. So the first line is what shows up. This ends up being the prompt. The entire thing, in fact, goes into the model as the entire prompt. And you'll [11:18] see that I've even said there's an [11:20] optional element down here. It says, if the user provides a topic, make a joke about that topic. Otherwise, tell me a dad joke. Okay, dollar arguments is where whatever you type in will go in. [11:30] Let's take a look at that. Two fish are in a tank. One turns to the other and says, "Do you know how to drive this thing?" Bad bum. Okay, let's briefly [11:37] talk about those custom commands. That one was within this file within this project. So, these are project settings that happen. We'll look at settings a little bit more in just a second. So, [11:46] just realize we're inside of this [11:47] project and there's a cloud folder. These are things that will get checked in depending upon your git ignore file so that other members of your team can get to it. All those kinds of cool things so everybody gets the same kind of experience. However, this folder also exists in your root folder in your home folder. So I have a home/.claude [12:05] and inside of that have some of these [12:07] things as well. And I'm going to confuse you real quickly, but I'm going to pull up another version of cursor here. This instance of cursor is actually pointing at my home directory and that clawed folder. So, it's just everything inside of mycloud folder in my home directory opened up here. And what you can see is [12:24] there is a commands folder just like we [12:27] were looking at. And I have created some commands in here. One for a get save kind of mechanism. We'll do a commit message, a special commit message that it does with different icons and things like that. And another one is a set of [12:39] project settings and design iteration [12:41] that we do. So, we need to really look at that one cuz that's one of the cool. ## 9. Coloring Cursor Command [12:44] [12:44] So, you might notice if I was you and I [12:46] was looking at this a couple weeks ago, [12:48] I would have said, gosh, I just wish [12:50] that I could get this more easily done [12:52] inside of cursor. I have a way of coloring all of my cursors. Now, this is just Visual Studio Code. You can color a project. It's been there for a long [13:00] time. I'm not inventing the wheel here, by the way, but I did use Claude Code to solve this problem for me because it's a little bit trickier these days in Visual Studio Code than it used to be to be able to do this. So okay if you remember we were looking at project level settings here there are also the the commands that are done at a at a higher level or my global level essentially my system level if I hit slash you will see that the gsave is there project settings is there so these other files that I've created here are actually also available here in every project that I run and that's one of the values of course is putting them in your home directory so that every project that you run gets them one of them though is very very cool. So we have to look at this one first. We're going to look at the [13:44] project settings which we just just [13:46] solved for. And if I want this version of cursor to be a different color, then I can just run project settings. And that project settings function I'm just going to let him run. If we come back and look at it, is not terribly complex. [13:59] It says we want to colorize the current [14:01] workspace for VSC. Here's the intent really what we're up to. tells it, hey, what we need is avo settingsjson file. Go create those. [14:12] Here's an example file as a default if [14:14] it doesn't exist. And that's all it's going to do. And you might notice in the background here, it did create this file. And once I accept that file, then it changes all of the color schemes. And [14:24] that's awesome, right? So now I have a theme environment just using this VS Code folder, very similar to the cloud one we just created, by the way. And if I do something like choose a different color theme here, then this project will look like that going forward, right? ## 10. Sub-agents: Multi-tasking! [14:39] [14:39] Very cool. Okay, there's one more interesting one down there that we're going to take on. So there was another one down here called design iterate. And what I've done in this design iterate is just said I want you to launch in number default of three concurrent subtasks. So [14:55] there's sub aents going on. One of the thing cla code can do and we'll see this in a second is it can run itself holistically. So, Claude Code is a CLI interface that can also run essentially headless, which means it doesn't need to show you anything. It'll just go and execute what you ask it to execute and then return the response value from that. We'll see that in a second. I have [15:13] some real cool things from that as well. What you can do is ask it to create subtasks. And what we're saying is for each one of the subtasks, I want you to create if the user gives you an image, a version of that UI because we kind of want to iterate on a UI idea to see if we can come up with some creative things from that. So what we're going to do is we're going to create a parallel set of calls out that are going to create as many kind of iterations as we want. [15:41] Let's take a look at that. We're going to come back to this guy and we're going to say we want to do oop sorry spinning around design iterate. So we want to design iterate and I want to if you recall use this clipboard object here. So that's the PNG. That's our image that [15:56] we're going to design iterate. And I want five designs some simply crazy. All right. I can see this is calculator interface with a dark theme. I'll create [16:05] five different design iterations. And what we're going to see it do now that it knows that it needs to do this. It's created the UI iterations folder and it starts creating these tasks. Create minimalist calculator. Create neon [16:16] cyberpunk calculator. Create retro80s calculator. These have not completed yet. They haven't even started yet. [16:22] Create 3D isometric calculator. And the emoji chaos calculator, which I just can't wait. So, you'll see they're all running at this point. Sorry. Sorry. [16:31] There are some issues with the UI here [16:34] sometimes. There we go. So, they're all running right now or kind of initializing and getting ready to run, if you will. And then you'll see that they keep they start and as they work through their work they'll update inside of this little task list. So each one of [16:47] them will have their own little [16:49] checklist and those kinds of things. It's worth saying I have asked over here for construct a standalone HTML page featuring one interface screen that addresses the user requirement or brief. So basically we're going to get this is singleshot HTML programming just so that we can get designs back. Once we get them then we can kind of steal some of the components if we like them. Let's [17:08] let this thing cook. Okay. And it's done. Let's take a look at what it came up with. We can kind of see them right [17:13] here, which is kind of neat. Let's load the first one. Oh, good lord. Okay. I [17:18] mean, I asked for crazy. What's next? Wow. Yes. Yes. I That's pretty cool. [17:23] Well, maybe some design issues here. Can't quite click them. All right. Eight. I got an eight. My eight minus. [17:30] Okay. Moving on. Okay. Excellent work. ## 11. YOLO [17:32] [17:32] Okay. We have three more and they're really fun. The last one I love. I actually love it. You might have already [17:39] experienced it here, but we'll see in a [17:41] second. So, the first one really super simple. Let's drop out here and we'll get back to shell and say, okay, Claude, dangerously skip permissions. Now, what I'm doing here, I want to tell you not to do. It's the right thing to do. Don't [17:55] start Claude this way. This will bypass permissions. I use it this way quite a bit, to be honest. So, I find this tremendously useful that I can just generally walk away from the system, allow it to do what it needs to do and cook. I have used it a lot and have not [18:10] had any issues with it. But that doesn't mean that it absolutely couldn't start eating things. It's not supposed to. So, be really really cautious about this at your own risk. Put your own protections [18:20] down the way you like. But, this one has been a real gamecher for me. I didn't ## 12. Claude as a Utility Function [18:24] [18:24] tell you about it. Okay, this next one is going to feel pretty esoteric, so live with me for just a second. And I have to describe a couple weird things to you. I'm going to bring up a utility here that I use to launch applications similar to Spotlight. If you're a Mac [18:38] user, you use Spotlight. I use something called Raycast. Raycast has the ability to allow you to run scripts. You write your own scripts and run them. In fact, [18:47] of course, I write all of my scripts [18:49] with Claude code. When I have a script, you'll see one of them is clipboard to downloads. This is using Claude itself. So, what this utility that I wrote or really asked Claude to write for me is doing is down in here somewhere, you'll see that it's using the Claude command just like we would by hand and running a command for us. Let's take a look. If I [19:10] have something on my clipboard, I'm [19:11] going to copy that. I'm going to show you my clipboard utility that this is copied onto my clipboard. And then I'm going to run this command, which is clipboard to downloads. And what it's doing is it's sending the whole text to Claude with another prompt that says, "Evaluate what's on this. I need a file [19:29] name. I need an extension for this. I need to understand what's in the file." And it gives that back to me. Then the [19:34] script goes forward, saves this into my [19:37] downloads folder so I have an actual [19:39] file and then also pushes that file onto [19:42] my clipboard so that I can paste that [19:44] file in certain places. So for this case, what I'm going to do so that you can understand what I'm doing here is I will paste the file right here just because it's on my clipboard as if I had dragged it in from my downloads. And I can say, is this the poem? And it says, yep, that's the poem. If I said, okay, [20:00] go grab this, you'll see I've grabbed a [20:02] hunch a bunch of markdown. And if I run it again with a wholly different thing, basically a blog post. This time Claude's going to come back and say, "Oh, well that looks like a markdown file. I'm going to save this as a MD." [20:14] and then you have a MD file. So, this just allows me to select things on the web and create files out of them very, very quickly. I do this very often as I need to move files around inside of LLMs more frequently than just a one-time text prompt that I'm dropping in. Okay, I thought I'd show you that. I know that [20:31] one's crazy because you have to know [20:32] raycast and scripts and all of this [20:34] other stuff, but this is just us using [20:36] claude as a utility at the command line [20:38] or within another script essentially to [20:41] give us data back and use intelligence [20:43] inside of what otherwise would have just [20:45] been a plain script. All right, moving on to the best one. The best one is next. My favorite, so hang in there. [20:50] It's pretty short, so let's get through [20:52] it. Okay, here's my favorite last one. ## 13. Hooks! [20:53] [20:55] It takes a little bit of explaining, but [20:56] not nearly as complicated as that [20:58] raycript one. Okay, the raycast one. So, here we go. What I am doing is I'm showing you first I'm inside of that claude project or the claude folder, the cloud folder inside of my home directory. So, this is just the base [21:11] area for settings for claude on my [21:14] system. And I just needed to show you that there's this settings file inside of this folder. And in many cases, you'll find this in inside of your project. So many projects will have these claude settings as well in the dotcloud folder like we talked about before. But what I've done at the top [21:32] level is I've put in something called a [21:35] hook. So if we come back to claude code itself and said I want hooks. Slooks is a slash command coming from claude itself. And if I go into this and you'll see they have five different types of hook. Pre-tool use, post tool use, [21:50] notification stop, and sub aent stop. So pre-tool and posttool is right before a tool starts to execute or right before the tool execution is done. You can kind of interject things. You can then be in the pipeline, which is great. Kind of a [22:04] plug-in interface here. Notification is sort of when Claude needs your attention. It's not just when it's finished and it gives you the prompt back, but when it might be asking you a question or prompting you for a selection to make or approval, something like that. Stop is when it finishes the work that it's working on at this moment. And that's the one that we'll be [22:25] showing. Stop sub agent is when you have a sub agent or one of these subtasks that's kicking off doing work. Every time each one of those stops, you can do something inside of that agent. All right, that's a whole bunch of conversation about something. What it [22:38] does, if I had gone in and set that up, [22:40] I just wanted to show you what it [22:42] writes. I have written a a a command here. Basically, it's just running a shell command called AF play. AF play is the audio framework for Mac. So you can [22:52] always drop down and do AF play point to [22:54] some path that is a wave file, MP3 file, [22:57] something like this. And this one just points at a wave file that happens to be on my my computer somewhere. Right? So this is just a standard wave file. And [23:06] what I'll show you here is that will [23:09] play once this is done. Okay. So that awesome chime every time cla code is completed in any project is going to kick off. That's what you're going to hear. I'm going to hear because [23:25] I put it at my root level. And I wanted to show you that because I'm compounding these things. So watch this. In this project, which is a service that deals with numbers, I have something that goes and reads a whole bunch of YouTube numbers. It was in my previous video [23:40] about cloud code. You can take a look at it there. And I felt like, oh, you know, who deals with numbers? stats up, bro. Other than, you know, [23:48] maybe a crypto bro. So, that one's great. But you heard both audio files playing here. If I look in here, this one has a clawed file in settings as well. And inside of its setting, it has [23:59] a stop hook. So, both of these stop hooks are going off at the same time. And that's the neat thing that's happening is I have two stop hooks. One at the global level and another one down here at this project level. And if I do [24:11] it at a third project, [24:14] oh, stats UI, then my stats UI project [24:17] also tells me, by the way, I made these [24:19] sound files with 11 Labs with [24:20] personality and all of this other stuff. So, a lot of cool stuff going on here, but this one is great. So, these things run off and take 10, 20 minutes sometimes to do their work. And I have four or five of them open a lot, very, very often. And so, I'm chasing them and [24:35] checking them over and over. I don't know which one, even if I just had that general sound, I don't know which one made the sound. So now I have them, some of them at least telling me what happened, who finished. So I thought I would share that. To me, this was the [24:48] most enjoyable, the silliest one, but [24:50] really makes me feel good when it goes ## Closing [24:52] [24:52] off. All right, I hope you enjoyed that. I had a lot of fun with these, just trying to pull together the top things that I'm doing inside of Claude Code that augment Claude Code itself that make it kind of useful. There are quite a few more that I do that I think are really useful and valuable. Cloud code [25:08] itself is a great environment, but with [25:11] just a few of these little tips that you [25:13] start to understand what it's trying to [25:15] do for you or how to make it more useful [25:17] or to kind of uh automate some of these [25:20] things like the subtasks, those sorts of [25:21] things are really really wonderful and [25:23] allow you to start really broadly [25:25] thinking how you can use this tool [25:27] rather than it's just simply a place you [25:29] ask a question and it creates you know [25:32] some kind of calculator for you. All right, I hope any of these were interesting to you. I have a feeling you hadn't seen one or two of them. With any luck, I hope. Um, I had a lot of fun [25:43] sharing them. If you like this kind of content, thanks for coming along this long. And thanks for being here. But subscribe. Please subscribe. I love [25:52] putting this kind of stuff out. And that signal really matters. It improves the channel. It certainly gets it a little bit more lift, but it also lets me know what people are interested in. Give me [26:01] comments, subscribe. It really does help. I appreciate it. Thanks for coming along for this one and I'll see you in the next