How I use Claude Code (Meta L7 Senior Staff Engineer Tips)

1. 0:00 – 1:04

   Intro

   1. JKJohn Kim0:00

      Well, hello there. How's it going, everybody? Today, we're gonna go over my 50 Claude Code tips. I've been working with Claude Code basically every day for about six months now, and I feel like I've learned a ton of things. And yes, I am one of those engineers that are basically not writing code anymore. I'm still in Claude Code, like, 12 hours a day, actively pair programming with Claude Code, basically, and reviewing a ton of code. I still read every single line of code. That's actually my biggest bottleneck right now, the reviewing of the code. But I thought it would be great to show you kinda the best tips that I've learned along the way, and these are kinda tips that I wish I knew when I was first getting started. We're gonna start off with some foundation stuff, like setting up, very quick set-up stuff, a little bit about, like, Claude.md rules, like what you should put in, what you should think about, and kinda some of the advanced stuff for later. But without further ado, let's dive into 50 Claude Code ti- So, I got my terminal here, and I just have some slides behind to, uh, tell you guys what I'm doing. So

2. 1:04 – 1:18

   ACT 1: Foundations (Tips 1-25)

   1. JKJohn Kim1:04

      here is the foundations that I mentioned. We're gonna cover getting started, keyboard shortcuts, some essential, like, slash commands, and a little bit of a deep dive into the Claude.md. So let's get started. All right.

3. 1:18 – 1:56

   Tip 1: Run from root directory

   1. JKJohn Kim1:18

      So for tip number one, you wanna run Claude Code in your root directory of whatever project you're working on. So for example, I have this Pomodoro app that I'm, like, kinda been working on, so I'll type in, like, Claude here, and that's essentially how you get started. And you really wanna do this because, uh, later we'll talk about this, but if you have rule files or any kinda setup, the initial root directory is where Claude is gonna zip up the context into that first token. So if you ever wonder why you had a bunch of tokens used even though you just opened up Claude, this is probably the reason why. It's because Claude's getting your project ready. All right. So one of the first

4. 1:56 – 2:54

   Tip 2: Run /init immediately

   1. JKJohn Kim1:56

      things that you wanna do is run /init, like that, and what this does is Claude will go and look at your code base and do a analysis of your code base and then create that initial Claude.md file in the .claude directory of your code base. Now, there is, like, different directories that you could source from. Like, you could have a global one or, like, this one. But yeah, at a high level, what this is doing right now is just, it's just looking at the code base, looking for the architecture, and then basically it's creating that Claude.md. All right, so it just finished. It does take some time, and as you can see, it's kinda going and saying, "Oh, this is, this is, like, a Next.js 15 app. It's, like, a portfolio site." But yeah, it's just going over high-level things about this particular project, uh, and then you could just essentially hit Yes to commit that to your .claude. So this is, like, really important for a new project, so I highly recommend you

5. 2:54 – 3:27

   Tip 3: CLAUDE.md is hierarchical

   1. JKJohn Kim2:54

      to run it. All right, so the tip number two is that Claude.md file that we just created, it kinda runs on a hierarchy. So if you go to memory, /memory, you could kinda see right here that there is a checked-in memory, which is the current root directory, and then there's a user memory. This is, like, your global one, so that's, like, in your ~/.claude/claude. So you could kinda choose between it, but it's, it's really there so you can know what the core rule that the Claude Code is operating on right now. Looking at the Claude.md that Claude just created,

6. 3:27 – 3:58

   Tip 4: Keep CLAUDE.md concise

   1. JKJohn Kim3:27

      like, this is a pretty good one to get started, right? It just has, like... You, you don't want it to be too large. It's, like, very small, right? I, I think around 300 lines is about a decent place that you wanna aim for. And to be honest, going larger is fine, but just remember that every time you increase that initial context window, you're gonna use more tokens, first of all, but also the more bloat you have in your context, the less likely the AI will do exactly what you're trying to do. All right. So for structure

7. 3:58 – 5:36

   Tip 5: Structure: What, Domain, Validation

   1. JKJohn Kim3:58

      and what you should be thinking about putting into your Claude.md, I just opened another project. This one is my anime Pomodoro. This is an iOS app, so I wanted to show you a little bit more examples. But basically, uh, the things I like to put is, like, high level technical architecture and the requirements. You know, like, what is the project? Like, that's kind of important. And then you wanna give it, like, some domain context, right? Like, oh, it's using SwiftUI, and I probably would add high-level architecture and, like, kinda the file path and things like that, and just some of the high-level design patterns, like you'll see. Like, all of that should go in here. And then one of the important thing is kind of having your build flow, like your validation flow, and this is, like, kinda where my build and validation is. So you can s- see that I'll, like, build the Xcode and then build the project, make sure things compile. Just having this loop of validation is so amazing because the AI will just be able to self-improve and keep going until it fixes itself. So, like, if you are ever in a situation where you just, like, ask Cursor to do something or ask some AI code agent to do something and it just doesn't work, a lot of that gets resolved when you fix the validation. And validation, I think as a side tip, is probably one of the most important topics that you should really think about when you're thinking about trying to build good AI agentic, like, coding systems or any workflows, is really h- what is the validation loop, because that will dramatically improve how good your AI

8. 5:36 – 5:58

   Keyboard Shortcuts

   1. JKJohn Kim5:36

      will be. All right, so let's go to some keyboard shortcuts, and the reason why I even have this entire section for this is because if you're gonna be in Claude Code all day, every day, f- like, if you're an engineer, you're just gonna be on this workhorse for quite a while. So you should learn how to actually use most useful hotkeys.

9. 5:58 – 6:40

   Tip 6: Shift+Tab toggles modes

   1. JKJohn Kim5:58

      And there's essentially Shift+Tab toggle modes is pr- pretty useful, and that's just, like, hitting Shift then Tab. And then you can see right here that we're switching from Accept edits to Plan Mode. I actually use Plan Mode quite heavily. I, I think I use Plan Mode almost exclusively whenever I start a new feature. It's rare that I start in Edit Mode. I always just want to verify and double-check that my assumptions about the codebase that I'm working on and the p- the direction that I'm trying to go with is the best option. So I usually start in Plan Mode, and I spend a decent amount of time before I go to Accept and just, like, start execution. All right, Escape interrupts.

10. 6:40 – 7:43

    Tip 7: Escape interrupts

    1. JKJohn Kim6:40

       Let me just get something started here. Tell me a good way to plan a live activity for when I background the app. Okay, so I'm gonna let this go to show you guys what escaping the interrupts is, but you can see that Claude is, like, thinking here, and it's, like, going through and doing things. Sometimes if... especially during Plan Mode, you wanna kinda, like, look at this and look at the thinking and see if it's going off track. If it is, you just hit Escape, and then it interrupts. Now, a lot of people might be, like kind of like scared to interrupt it, but you can just, like, hit up and then go right back to where you were doing, or you could just interrupt it and tell it something else. The whole point is Claude Code has a really good way of, like, deduping and entering prompts in a nice queue. It, like, it logically knows what to do. So you don't have to be so scared to, like, enter more than one prompt and also, like, escaping early and interrupting and changing course. Like, it's actually recommended to do that. Tip number eight is

11. 7:43 – 7:59

    Tip 8: Double Escape clears input

    1. JKJohn Kim7:43

       if you ever have something, like, really big where you copy-paste something and you're like, "Oh, I don't wanna delete everything," a handy shortcut here is just double-tap Escape, and it'll clear the input. There's also a Vim mode if you're into that, but I use this all the time. Another thing

12. 7:59 – 8:29

    Tip 9: Double Escape on empty = rewind

    1. JKJohn Kim7:59

       is when you're on a empty input, if you double-tap Escape, you'll see that you can rewind to, like, a previous point, uh, and then restore that context point. This is kinda common with Claude Code, but a lot of the tools I feel like is really built to manage your context and context engineering, and then there's just, like, an agent that is wrapped around the orchestration. But a lot of the, like, slash commands and stuff that we'll be going over, I feel like it's, it's really to manage that context window. All right.

13. 8:29 – 8:44

    Tip 10: Screenshot and drag

    1. JKJohn Kim8:29

       Screenshots is obviously a pretty common thing to do. There's a lot of ways to do it, but you can essentially take a screenshot and then drag it over and just drop it in. And then obviously another good tip is to add context.

14. 8:44 – 9:09

    Tip 11: Add context to screenshots

    1. JKJohn Kim8:44

       This is a cool picture of the Claude Code mascot. Do something with it. I don't know. [laughs] But yeah. So that's a really good example of, like, taking a screenshot and bringing it over. If you are doing any kinda UI work, you'll definitely use this workflow. I also highly recommend finding, like, a Figma MCP or some form of MCP that works really good with the specific validation that you're trying to do.

15. 9:09 – 9:41

    Essential Commands

    1. JKJohn Kim9:09

       All right, moving on to essential commands, and this is slash commands. Before I end on the keyboard shortcuts, there's a lot more keyboard shortcuts, things that I don't use all the time. If you just go to, like, /help, you'll be able to see a bunch of them. But the ones that I covered I use all the time, every day. So definitely just memorize it. I think it would be really useful. Now, essential commands is, like, the slash commands that I think you should know about. Uh, there's way more slash commands, and you could, like, make your own slash commands, but these are the ones that I think is useful. All right. So

16. 9:41 – 10:13

    Tip 12: /clear resets context

    1. JKJohn Kim9:41

       /clear is basically a way to clear the context. Now, you could actually do this by just creating another instance of Claude, right? That's basically the same thing, but if you don't wanna, like, do that, you could just clear the context. And this is really good if you wanna start a new feature and you're completely done with the old task, and you don't want the old context to blow up the new context and influence the new project that you're doing. All right, so I just loaded some stuff. Let's, uh, go into /context.

17. 10:13 – 11:42

    Tip 13: /context shows token usage

    1. JKJohn Kim10:13

       What this does is it will give you, like, a visual representation of the current context that Claude Code is operating in. Now, why is this useful? So the main reason why this is useful is because it gives you an opportunity to reason about the context that Claude Code is making assumptions on on your codebase. Now, I always say context is best served fresh and condensed, and you really want to take a look at this from time to time. If you ever felt like Claude Code has regressed and, like, things are not working the way it is or your, like, cost and usage, like, bill is going up, you really wanna look at this and then see which are, like, the most biggest offenders, right? You just wanna, like, audit it. Like, MCPs are one of those very common things that blows up your tokens. I mean, like, look at all of this Xcode-related MCPs, and every time it runs it, like... I mean, these are not a lot because I haven't been doing that much in this particular workflow, but you could just imagine that once I start doing those iteration cycles, this, like, usage will, like, blow up. But yeah, so if you look at this and you're like, "Oh, I- this MCP is using so much," uh, then you could remove it or just disable it for this directory. So /context is something that you probably should not ignore. Again, I think Claude Code, all of the tools, is really there to manage a lot of the context and doing really good context engineering, so this is a good- /command. All right, so in

18. 11:42 – 12:23

    Tip 14: Let auto-compaction work

    1. JKJohn Kim11:42

       terms of compaction, like if you use Claude Code at all, if you had a long session, it will start auto-compacting at some point. All auto-compaction does is just takes your current context window, like context that you created, and then it will just summarize it, and then it does a pretty good job. For my projects, I usually just let the auto-compaction work, but if you really want to compact what you have right now, you could just compact. [laughs] But I, I rarely use this. The only time I use this is if I wanna save some version of my context into like my local like second brain. If you haven't seen that video, go and check it out, but I have this second brain concept when I work on projects, and that's where that goes. So

19. 12:23 – 12:49

    Tip 15: /model switches models

    1. JKJohn Kim12:23

       for /models, this is like very useful, I think, if you have unlimited tokens, like if you're doing this at work. For me, I usually just, uh, default it to Opus 4.5, but if you're very like cost sensitive and you know certain workflows work well in Sonnet or like Haiku, then you could just go and change that. Um, keeping it at default is fine too, but I would try to use Opus as much as possible. All right, so /resume

20. 12:49 – 13:21

    Tip 16: /resume recovers sessions

    1. JKJohn Kim12:49

       is really useful if you accidentally like lost your instance. Let's say you created another one, and then you accidentally killed it or something like that, right? Or you kill the wrong one or something. Then when you go back into Claude Code, you could just /resume, like so, and then it'll give you kind of the old context, and then you could like recover your context so that you don't lose the, all the work that you did in building up that context window. All right, /mcp is really

21. 13:21 – 14:19

    Tip 17: /mcp shows MCP status

    1. JKJohn Kim13:21

       about, um, showing the MCPs that you have installed. If I have to be honest, I try very, very hard to not use MCPs because I think they blow up your context window, so I only install ones that are needed for that very specific project, and I try to just leverage Claude Code and write scripts and like these kind of things manually, like myself, to do the validations and things like that. But some projects you just do need MCPs. Like this Xcode one, you kinda need it, and for other projects like my Next.js apps, I have like a whole set of MCPs for that. But just be careful with MCPs, but it's a really fantastic way to teach Claude how to do certain things, especially with like third-party software and things like that. You know, it's a protocol, right? Model context protocol. So it's basically used everywhere, but again, it's known to blow up your token usage and your context window, so just be careful. All right, so /help

22. 14:19 – 14:33

    Tip 18: /help shows all commands

    1. JKJohn Kim14:19

       is the last thing I'm gonna teach you. You know, teach a man how to fish. So this like little wizard here will just teach you what they are and give you like descriptions of everything, so just go ahead and like try these out and just take a look and, you know, explore. All right, so the

23. 14:33 – 15:24

    Tip 19: Git is your safety net

    1. JKJohn Kim14:33

       next thing is around Git. So you could ask Claude Code to manage your Git. I think there's a bunch of like skills you could download to Claude Code to manage all your Git, and I think that's something that you should do. Like I u- write a lot of my summaries and test plans all using like Claude Code now. Obviously, I have my own templates that I wrote so Claude kind of sounds more like me and is not too verbose and things like that, so I highly recommend you to use Git as a safety net. There is actually a rewind feature, like I think I told you, where you could restore the code and the conversation. But this is a little confusing to me, like Git is just better. I use this as like a last resort if I didn't have Git [laughs] for a certain checkpoint. So now that you know how to just navigate around Claude Code and things like that and just kinda high level important like commands and things like that, I

24. 15:24 – 15:52

    CLAUDE.md Deep Dive

    1. JKJohn Kim15:24

       think it's a good time to deep dive into the CLAUDE.md file. I think for most people, most users, like 80% of users, if you just have a really good CLAUDE.md file for your project, you could get really, really far without learning like all the advanced stuff. Just having a really good rules file will save you a lot of headaches. Let's kinda dive a little bit deep into this. Okay, so

25. 15:52 – 17:08

    Tip 20: Add a Critical Rules section

    1. JKJohn Kim15:52

       one of the most important things in the CLAUDE.md files is, first of all, it's like it actually reads top to bottom, and it keeps the priority from top to bottom. I think that's like a very small nuance. I'm pretty sure that's true. [laughs] I think I read that somewhere. But it... Yeah, so you wanna go top to bottom as like important to least important, and you wanna add things that are like never do something, but always do this, and then have like clear snippets of examples I think is really good. And I don't have that many on this particular project because it's stock SwiftUI, but the context here is that you should really think about how unique is your project, how many things about your project is like homegrown and essentially like the AI may have never seen. Like remember, a lot of this code is like basically... A lot of the AI like coding is basically just s- an accumulation of like the best code that the AI [laughs] is trained on, so it might not know your like super special DSL language that you created or like some random archaic patterns that your company has, and that's where you'll be like, "Oh, why is the AI never doing this?" So whenever you run into something like that, you wanna fix it manually,

26. 17:08 – 17:46

    Tip 21: Ask Claude to update rules

    1. JKJohn Kim17:08

       and then you just update your CLAUDE.md rules so that it never does that mistake again. Think of it as like lint files kind of, and then when you ask Claude to update the rules, you shouldn't ever do it manually. You should just go here into Claude and s- and say, "Hey, can you update that rule for me so we never do it again?" Something like that. Like as simple as that will go and update the, your CLAUDE.md files. You see how it's trying to do it? Obviously, there's nothing that I just did, so it says nothing to add. But yeah. Okay, it, it added something that I thought, but you get the point. All right, so this

27. 17:46 – 18:27

    Tip 22: Use workflow triggers

    1. JKJohn Kim17:46

       next one is really around using, like, keywords to trigger your skills. So basically, I have these, like, build commands inside of my rules, so when I say, "Hey, use my Xcode MCP to build," it'll try to build a app, for example. Use my Xcode MCP to build the app. Okay, my whisper stuff is, like, failing a little bit, but maybe you'll get the gist of it from build the app. And as you can see, it's, it's asking if I can use the Xcode build MCP. So that's kinda the high level of, like, using skills and, like, trigger words to be able to trigger certain behavior. This next one is something called, like,

28. 18:27 – 19:34

    Tip 23: Commit CLAUDE.md to git

    1. JKJohn Kim18:27

       compound engineering. That's, like, kind of a new term that is being discussed, but it's essentially to take your CLAUDE.md and start, like, committing it into the code base. Now, obviously you need to get rid of anything that's, like, generic for your code, like file paths and things like that, and you also wanna be mindful of how large this file becomes, right? Because, like I said, every time someone hits Claude in that directory or Claude trying to read that directory, it will load that CLAUDE.md file. So you don't wanna blow up other people's context windows, so you really wanna be- have this be, like, a high bar when you're committing it. But the nice thing is once that's in, you essentially make that AI coding experience better for your teammates, but you just need to make sure that whatever you're landing is actually helping. There's a lot of school of thoughts around this right now. I don't think it's, like, completely solved, but there's gotta be some form of evaluations here, and a lot of people are just using, like, vibes. So you just, like, test it for, like, a few weeks, and then you just try to land it aft- and then s- ask for feedback essentially.

29. 19:34 – 20:39

    Tip 24: dangerously-skip for throwaway envs

    1. JKJohn Kim19:34

       So dangerously skip is essentially, like, Claude Code and Yolo mode. Um, you know, uh, like, just basically, if you use Claude Code, it'll ask you to accept a bunch of stuff. It could get really annoying, so a lot of people, they use, you know, Claude and then --dangerously-skip. Okay, uh, so it's --dangerously-skip permissions, and when you run this, Claude Code will no longer ask you essentially to accept that edit. I think it will completely just ignore it, except for, like, anything you put into your /permissions, which we'll talk about. But you only really wanna do this in, in environments that you can kinda throw away, and you're doing specific work that is not, like, super dangerous. Like, if you're gonna start touching the OS and stuff like that, you could really mess it up. I messed up some of my Linux machines because I was just going too aggressive, and I was just testing it out, and I was trying to set up some of my Linux stuff using Claude Code. And then, like, I had to reflash the entire thing. Like I said, you can use /permissions

30. 20:39 – 20:59

    Tip 25: Combine skip with allowlists

    1. JKJohn Kim20:40

       here to kind of like, uh, tell which ones are... like, you still want to accept. [laughs] So it d- you know, like RM-RF or something, like, don't do that or... [laughs] Yeah, just, like, mutations, like, just be careful with mutations, like deletion mutations, right? Um, all right.

31. 20:59 – 21:38

    ACT 2: Daily Workflow (Tips 26-32)

    1. JKJohn Kim20:59

       The next big one I think, now that we talked a little bit about the CLAUDE.md rule, uh, files, I think w- we should talk about workflows because I have a very specific way I like to work, and I've actually refactored my entire work so that it's works with Claude Code. You know, I used to use Cursor or, like, Android Studios mostly and VS Code to do a lot of coding and stuff like that, but I dropped basically all of that, and I use just iTerms now. Um, some people use, obviously, Vim, but I think iTerms is fine. So I'm gonna show you guys a few things. So

32. 21:38 – 23:46

    Tip 26: Start features in Plan Mode

    1. JKJohn Kim21:38

       like I said, I always start with Plan Mode. Let's go in, like, plan, like, a little feature for this Pomodoro app that I've been, like, kind of working on. I don't know. I actually need to remove a bunch of audio stuff, so let's just say audit my code base and make sure that we're removing all of the audio playback and references to the audio of... part of the Pomodoro app. I always start with Plan Mode, and I'm, like, iterating with Claude Code. I'm arguing with it. I'm having a conversation with it. You know, "Claude Code, you're so beautiful. You're so amazing." [laughs] No, but, like, I'm really treating it as, like, another, like, just good engineer that I'm, like, working with, and I'd never just, like, purely accept the first answers that it gives to me. I'm always kinda challenging it, and I spend a lot of time and put a lot of effort at this stage of the development because I feel like once Claude Code builds out that context and have good execution specs, the generation of the code is actually the easy part. And I, I do wanna take a moment and talk about, like, kinda the news cycle about people saying, "Oh," like, "people are no longer writing code." I think, like, the creator of Node.js said, like, the era of, like, people writing code by hand is essentially over, and I actually truly believe that. And the thing is, I love, like, being in the zone and writing code. At least I used to. The thing is, it's really hard to get back into that mode. It's, like, very different levels of abstractions of the way you're working, and right now I'm just doing one instance of it, but you could imagine, um, just having, like, multiple Claude instances like this and, and, and then you're just actively working on a bunch of thi- different things at the same time. Because you have this, like, s- new superpower, the new next level of engineering is really, like, jumping between Claude instances and, and really context engineering that instance and then getting it good enough to start executing. And I keep talking about this, like,

33. 23:46 – 24:29

    Tip 27: Fresh context beats bloated

    1. JKJohn Kim23:46

       context, right? And this tip is really around, like- Fresh context beats, like, bloated context. I think I kinda cover this throughout this, but that's why you wanna start with Plan Mode, make sure it's good, and then just go and execute, instead of, like, having a bunch of, like, try this and then try that, and then try this and then try that. Like, that will just bloat that context, and then the AI will get really confused at some point because it, it can't remember what, what part of what was good and not good. So that's why you wanna spend the time in the beginning building up the good context, have a good plan doc, so it always has something that initially was good to reference, and then it builds little by little. All right, so this next

34. 24:29 – 25:03

    Tip 28: Persist before ending sessions

    1. JKJohn Kim24:29

       one is really around, um, persisting that context. Uh, I have a full video on this about, like, the second brain concept, so I'll link it here. But the idea here is that let's say you've finished something, you could just say, "Save this to my local Claude.md in my projects directory. Save the work that we just did." So you, you could say something like that, and then, um, I, I essentially have a full workflow for this to manage this, but yeah, you, you could do that. Load my context from my

35. 25:03 – 26:09

    Tip 29: Lazy load context

    1. JKJohn Kim25:03

       local projects. So once you have that second brain concept, you could say a command like this, and it will pull that context and then load it for your new session. So here's a good example. I like to do a lot of my to-dos inside of Claude Code itself. These are kinda the high-level things that I still need to do for this next feature that I'm working on. So I'm, like, working on a widget for this Pomodoro app, and I have, like, a live activity, for example, and I'm also, like, deleting all the music stuff because I don't think it adds value. So I have a bunch of stuff that I'm tracking, but because I keep all the to-dos in my local index, like, that I'm lazy loading, I don't always load it, I only lazy load it when I ask for it, it allows me to, like, context switch from project to project without, like, carrying around, like, complex, I don't know, Asana boards or whatever. I just keep it all in here, and it's... This is, this works because it's my own project. But you can technically do this with, like, an MCP with Asana or, I don't know, Jira or whatever, as long as [laughs] you can... Whatever project management that you can think of. All right, so I think we covered

36. 26:09 – 27:32

    Tip 30: Give verification commands

    1. JKJohn Kim26:09

       this a little bit, but really think about the build cycle. Like, obviously, if you're mobile, think about Xco- building the Xcode. But there's a lot of other workflows that you could think of. Like, for example, you could ask Claude Code to... Like, let's say you're debugging something that's, like, kinda tricky, has, like, race conditions or things like that, you could ask Claude Code to, like, add debug logs, for example, and then run the app, and then have Claude Code control the emulator. You could just ask it to do that, and then, like, do the actions that you're trying to do, and then read the logs through a tail log or something, and then debug that way. Or you could use, like, Perfetto or something like that. So for kinda performance things, you could hook into Perfetto MCPs, do a run, and then have it read the traces, and then see if it can find jank just from, like, the timings, right? There's just so many validation loops that you could think of. Like, for web, you could do, like, Puppeteer and have Claude navigate it using a /chrome command, and then just actually do the navigation or have it write Jest tests or have, like, integration, end-to-end integration tests. You know, there's, there's a lot of things that Claude Code could do, and it really is up to your imagination. But it's the single most important thing, in my opinion, if you wanna have a more automated loop that, like, generates good code on, like, the first try. So going back to the /models,

37. 27:32 – 28:18

    Tip 31: Consider Opus for complex work

    1. JKJohn Kim27:32

       really just consider using Opus if you can afford it. It's just the best way. All of these are a little bit slower, but because, uh, the way I work is I have multiple Claude instances, obviously it's, like, very small, right, in here, but I have, uh, multiple Claude instances running at all times. And then the way I work is basically just juggling these Claude instances. So even if one of them takes a long time, it doesn't matter because I'm, like, I gave the command, and I go to the next one, I'm building the context, I give a command, and I go to the other one, and then I give a command. So, uh, so, like, you end up, like, still can get into the zone, but it's, like, a different style. So I talked a little bit about interrupting earlier,

38. 28:18 – 29:01

    Tip 32: Read thinking blocks

    1. JKJohn Kim28:18

       but you really want to, like, look out for, like, assumptions or... The keywords are like, "Oh, I'm not really sure," or you'll see, like, errors happening. "I'm having a hard time, like, getting it to do this," in this example. But, um, just, just know that, like, when you go and look for the best ways to delete an app. I don't know. [laughs] I, I'm just giving it a random prompt to try to make it go off course, but if you see it going and making assumptions about certain things... Okay, this time it didn't even really, 'cause it's just new. But you should just interrupt it like that, you know? And then, and then just course correct it. So don't worry about course

39. 29:01 – 29:34

    ACT 3: Power User (Tips 33-40)

    1. JKJohn Kim29:01

       correcting. Okay, so the next section is around power users. I, I don't really like to say power users, but most people that I've talked to don't really know, like, the differences between a slash command or a skill. They're, they're kinda interchangeable now. And MCPs, subagents, you know, post hooks, pre hooks, like, these kinda primitives that Claude Code is, like, known for and kind of, like, invented, and we're gonna cover some of that and, and how this, these are all, like, composable in nature. Okay, so I call it the composability framework,

40. 29:34 – 29:54

    Tip 33: Four composability primitives

    1. JKJohn Kim29:34

       but it's... I just really wanted to highlight that these are composable more than anything. But there's four primitive, like, composable things. All the slash commands are technically composable with each other. Not directly each other, but anyways. So we're gonna just go over the fact that, like- how these are composable, okay? So let's first

41. 29:54 – 31:33

    Tip 34: Skills = recurring workflows

    1. JKJohn Kim29:54

       talk about skills. All a skill is, is it's like you do a workflow. So let's say that, um, I tell Claude, "Go and fetch Hacker News for latest iOS news." So let's say I tell it to go and fetch Hacker News for the latest iO- OS news, and then, uh, and then I tell it to save that. Okay, and then save, um, a summary to my local, uh, claude.md Claude directory. Okay, I misspelled that, but basically, let's say that it went and found some, and then it's save it into my local directory. Let's say I wanted to build a skill around that. So you just saw me do two things. One is fetch something from a source, like Hacker News, and then save that thing to my local directory. That's technically a workflow. So all you have to say, do is save what we just did into a new skill called Fetch Hacker News. And that's basically it to create a skill. It's basically a recurring workflow that you can just tell Claude to remember, and behind the scenes, it's actually just an MD file, as you can see right here. Oops. And as you can see here, it's literally just a system prompt. It's an MD file, but Claude has specific directories that it's looking for skills, and it will be able to infer this next time I say, "Go fetch something from Hacker News," or, "Use my Hacker News skill to fetch articles." Yeah, and then

42. 31:33 – 32:18

    Tip 35: Commands = quick shorthand

    1. JKJohn Kim31:33

       Commands is basically now interchangeable. It's, it's a pretty recent change, but you can see that, um, Skills is written into the skills documentary, and it, there's also now a /command called /fetchhackernews. This is a very recent change from Anthropic, where they kind of, like, combined, uh, commands and skills. But yeah, so now you can just do /hackernews, and then now it will rerun that system prompt, for example. It added, like, an additional, like, assumption thing. That's pretty cool. It's not exactly what I did, but it kind of infer that I would probably want that. So those are the little cool things. And, and the thing is, you could update these any time you want. You know? You could just ask Claude to do s- do something else. All right,

43. 32:18 – 33:02

    Tip 36: Never create commands manually

    1. JKJohn Kim32:18

       so like I said, you never wanna manually create these kinda stuff. You wanna get in the habit of asking Claude to update and manage these skills. So we could say, "Why don't you extend this fetch Hacker News to fetch Twitter or Apple News?" For example. Now, sometimes it won't work 100% exactly right. Okay, so you see this? It doesn't have Twitter authentication access, so it's trying to just do some other ways. [laughs] Yeah, multiple sources. So it... You can see how it's all updating that r- system prompt that we wrote, right? And then fetch Hacker News, and so forth. You, you get the idea. All right, so MCPs,

44. 33:02 – 33:52

    Tip 37: MCPs = external service docs

    1. JKJohn Kim33:02

       I think we covered it a little bit during the, the rules, but basically, MCPs, you just wanna find MCPs like this, right? Y- like, they're just model contexts. But kind of a hack is, like, you don't actually need to search the web for an MCP. You could just be like, "Find me a good Figma MCP." You could just ask Claude to find it for you, and then most of the time it does a good job. The only thing is, like, uh, sometimes [laughs] it's outdated, so it'll, it'll, like, know of one that's, like, was popular a little while ago, rather than doing a web search. So you just have to be mindful, and that's why I'm saying, like, for certain actions, you wanna read how, what it's doing and, and look at the thinking, and then cancel it if you want to. And you could have Claude also install the MCP

45. 33:52 – 34:15

    Tip 38: Ask Claude to install MCPs

    1. JKJohn Kim33:52

       so n- you don't have to, like, manage, like, the configs and stuff yourself, like you had to with Cursor. Yeah, so you could ask Claude to install the MCPs. So, like, right here it says, "Go and do this," right? But instead, I could just be like, "Why don't you just install this for me?" For example, and then it will just go and install it for you. [laughs] All right, so in terms of subagents,

46. 34:15 – 37:10

    Tip 39: Subagents = isolated context

    1. JKJohn Kim34:15

       I don't know if I have one for this. I might have, like, an iOS... I might have one, like, an iOS, like, context gathering or, like, architecture agent. Let me try it. So spawn a iOS architecture agent, subagent, and do some investigation on, and on my codebase and see if it's actually good or not. Um, so you can build subagents just like you can with, uh, slash commands and skills. All you do is just ask it to make a s- subagent after you do the work once. The main reason why you want to create a subagent is really to do parallel work, but also it's to protect your context window. So like I said, one of the key features of Claude Code is to manage your context and do context engineering, and subagent is a huge way. And I think a lot of people are using subagents incorrectly because they do things like this, where [laughs] you have, like, an iOS subagent, right... By the way, it's not triggering the subagent. I'll just make one a- after it creates it and show you guys what it looks like. It, like, highlights it in, like, a different color. But a lot of them have this, like, workflow where they'll tell it to go do something that does the context gathering, and then they ask to, like, bring it back. But that part, that portion of the context that's bring- brings back from the subagent, it's only, like, the output. It's not, like, how it got there, so it doesn't have the full context. So for those kinda works, I usually just keep it within the context window because those are the things that are really good. Use what we just did to create a iOS architecture subagent. But yeah, so, so oftentimes people mistake that you wanna, like, have a Validator agent, you wanna have, like, a testing agent, and all these kind of things, but I try to keep the, all the things that need that context to do its work within the same Claude Code session. Because, like, a good testing agent needs to know about the code that it wrote most of the time, in my opinion. Of course, sometimes things could live in isolation. So what are really good things for subagents is really just, like, things that are atomic in nature, that you wanna ha- just have it run as side effects and just go and do. But yeah, so that's what I use subagents for. I don't use subagents that often. I know some people, like, love using them, but one of the most common, like, clowny kinda use cases that I've seen is, like, CEO agent, product agent, design agent, and stuff like that, and I don't really believe in that particular workflow. Like, you really wanna have this concept of bringing the work to the context rather than trying to spread out the context that gets created. All right, so, and this kinda ties into it,

47. 37:10 – 37:48

    Tip 40: Avoid instruction overload

    1. JKJohn Kim37:10

       like, you wanna avoid, like, having a lot of instructions and overloading the context all the time. You wanna keep your context condensed and fresh, so that... Watch my video on the second brain, and you, like, that's... It'll teach you a lot about, like, lazy loading, and then having this, like, a ongoing project domain thing that builds over time, and you wanna s- essentially use that as your rack system to build, like, a good context, and then be able to just have fresh and good context all the time for your AI to execute on. All right, so here is some interesting, like [laughs]

48. 37:48 – 38:02

    ACT 4: Advanced (Tips 41-50)

    1. JKJohn Kim37:48

       advanced workflows, and I really think that the big game changer, in my opinion, for Claude Code, and why I think Claude Code is just so amazing, is that you can do a lot of parallel development.

49. 38:02 – 39:06

    Tip 41: Run multiple instances

    1. JKJohn Kim38:02

       This is why I had to, like, fully change how I work using, like, terminal and stuff, because you could run multiple instances, and I already kinda showed you guys this, but you could just swap between these and just have, like, multiple things running at the same time. So I could say, "Start working on my live activities feature," so I could just have that. Obviously, I would do it in Plan Mode, but I'm just showing you guys. And then over here, I could just say, "All right, let's test out this iOS architecture," and, and then just spawn a subagent. So as you can see, I'm doing some investigation on one side, and then I'm doing live code editing. But the thing is, I could always just create another one, go to, like, a different project, like this, and then now I could be saying, "Hey, I wanna work on a new newsletter," for example. So I could be doing a bunch of stuff all at the same time, so that's, like, a really... So understanding how to juggle this and doing it effectively, I think, is, like, the next step function change. And

50. 39:06 – 40:33

    Tip 42: iTerm split panes

    1. JKJohn Kim39:06

       I just wanna kinda shout out iTerms. I think it's, like, really good, um, because, you know, you could do Command+D to create new instances like this, right? And then you could juggle between, uh, the terminals using Command, um, uh, the left bracket and right bracket. Like, ignore this, like, slash. It's like I'm just saying, oh, it's left bracket or right bracket [laughs] , like slash, right? But yeah, so... And you could do that. You could also, if you have multiple tabs like this, you can actually swap between it. And at work, what I do is I rename, like, what I'm doing in here. Like, I'll say local, and maybe here I'll say, like, remote SSH or something like that. And then from the remote SSH, I could have Claude, like, running like this, and I could spawn a more, you know... And then, and then I could just be going back and forth here. So it really feels like I'm playing StarCraft to some degree, right? And all of these I'm just doing with, uh, my keyboard. And when I'm home, I'll just, like, be in Whisper, using Whisper, which is, like, this voice little thing that you see right here, and it just translates speech to text really quickly. Sometimes it's not that accurate, but... So I'm just, like, switching, switching, and I'm just basically talking to it, you know, [laughs] just literally working as, in multiple projects all at the same time. I think my bottleneck right now is really how much context switching I can do in my head. So yeah.

51. 40:33 – 41:10

    Tip 43: Enable notifications

    1. JKJohn Kim40:33

       Another thing is enabling notifications. You could tell Claude Code to change the notifications, right? Uh, you could just say, "Change the notification to s- ring a little sound when you finish execution," for example. And then when it's... Now it'll basically ring [laughs] like a little notification. A- and you could do a lot of things. At one point, I had, like, um, text to speech [laughs] where it, like, reads a summary [laughs] of, uh, one of... Wherever it finish, it will read a summary. So I could be like, "Okay, I gotta go back to tab two and then go do something." Um, but that was too much, so I disabled it. Git worktrees

52. 41:10 – 41:40

    Tip 44: Git worktrees for isolation

    1. JKJohn Kim41:10

       is another way to do multiple code execution. So one of the bottlenecks that you'll see is if you have these kind of, like, bunch of multiple instances, you'll soon realize if you're doing local development, you won't be able to make code edits to the same project unless you use Git worktrees. And I'll add some descriptions on how to use Git worktrees, but basically it's, it's a way to, like, clone multiple instances of your code base and have, like, different forking branches. So you could have, like... You could work on, like, code, like, executions in the same project.

53. 41:40 – 43:17

    Tip 45: /chrome connects browser

    1. JKJohn Kim41:40

       Uh, /chrome is actually a really cool tool, in my opinion. So the way you get to it is by just doing /chrome like this, and then it will go to, like, /chrome, and then it will open this thing. You can't see it here, but there's, like, a little button, and it just opens it, and you could actually navigate the browser. So go to tip number 46. So what it does is it will look at the website, and it will... And you could approve the plan. You could allow the action. So basically, it will create the plan, and then it will, like- Do it. Okay, it doesn't, it doesn't really know how to do it. So, um, I'll say hit... Le- let's just try YouTube. I think YouTube might be easier. Okay? So we'll, we'll open YouTube, and then say, "Find a video on cooking," for example. Yep. So you can see that it, like, takes a screenshot. It will, like, click. It'll type cooking, and then it will, like, find cooking videos, for example. And then so I use this whenever I don't have API access to certain things, but I can get there via my web. And, and because you could control it via /chrome, you can have it as part... Like I mentioned, that all of these are composable, so you could have a command that goes to Chrome, scrapes a bunch of stuff, and comes back to you with the data. Okay, so moving

54. 43:17 – 43:28

    Tip 46: Powerful for debugging

    1. JKJohn Kim43:17

       on. Like I mentioned, it's really good for power for, like, debugging, right? You can navigate the web with it. Uh, that's also part of the validation thing that I was talking about. You can fill out forms and stuff. All right.

55. 43:28 – 43:41

    Hooks & Automation

    1. JKJohn Kim43:28

       Hooks and automation is really just, like, kind of the cherry on top, and this is very similar to, like, GitHub's pre-hooks and GitHub's, like, post, like, commit stuff, like, re-commit stuff.

56. 43:41 – 44:10

    Tip 47: Hooks intercept actions

    1. JKJohn Kim43:41

       So basically, these are hooks, and a- as you can tell, it's just, like, something to do before you start executing or after executing, and after executing fails. Like, there's all these things that you can do, and you shouldn't manually do this. You should just ask Claude to, like, add these for you. You know? Like, go back to that principle that you're no longer main- manually maintaining your work environment. And a good example on what to put here for the PostToolUse

57. 44:10 – 44:24

    Tip 48: Auto-format with PostToolUse

    1. JKJohn Kim44:11

       is, like, you know, things like, uh, arc- like linting and, and formatting your code and things like that. And I'm not really using this yet, but basically, uh, this is really good if you wanna block,

58. 44:24 – 44:43

    Tip 49: Block dangerous commands

    1. JKJohn Kim44:24

       like, removing your entire, like, database or something like that. This is just, like, good, good to prevent very destructive things. I haven't really set it up because, you know, I have, like, r- remote backups, and also this is, like, side projects. But for real work, you probably want something. And finally, with that, I think

59. 44:43 – 45:32

    Tip 50: Explore the plugin ecosystem

    1. JKJohn Kim44:43

       you got the vast majority of, like, the best tips that I know for Claude Code. Um, the last thing I'll leave, uh, with you is to explore the, like, the plugin ecosystem. All a plugin is is a, just a combination of any of these composable things that I talked about, like a skill that triggers an MCP that triggers, like, subagents or something like that, or maybe there's, like, a Bash script that's attached to a skill. That can all be turned into a plugin, and then a lot of people share their plugins online. So this is, like, a really good example. You know, Anthropic has their own, like, plugins, like, structure, and they have a bunch of plugins here that you could download, for example, um, like call an ISP and things like that. So that's basically it, and the last thing I wanna say

60. 45:32 – 46:12

    Context is King (Outro)

    1. JKJohn Kim45:32

       is context is king. You gotta keep it fresh, keep it relevant. You essentially need to give Claude the context that it n- needs and nothing more. [laughs] But yeah, so go and build something amazing. I hope this was valuable to you. I hope you learned something. Go and build something amazing, and if you're interested in this kind of video on Claude Code, uh, I did a whole video on, like, kind of the high-level thought process of, like, AI coding and, and also talked a little bit about my second brain thing. Those two videos are right here, so go and check it out. But yeah, until I see you guys on the next video, bye.

Episode duration: 46:12