Claude Code: Tips and Tricks [AI Tinkerers - Post-Training]

Below is the general structure of this guide. Feel free to jump to the section that most fits your level. At the bottom, I have a cheat sheet with all the tips mentioned here in a condensed format. Here’s how this article is structured:

• Getting started with Claude Code: Start here if you haven’t tried using Claude Code before. This section will cover how Claude Code works and how to set it up.
• Context Engineering for Claude Code: Start here if you have used Claude Code, but are aiming to sharpen your context management skills, and learn some extra tips. This section will cover how to best manage the context of your Claude Code session. We’ll go over the Explore, Plan, Execute, Commit framework and also discuss managing the CLAUDE.md files and how to make use of the /resume command and double escape.
• Commands, Subagents, and Hooks: Start here if you’re already a power Claude Code user and want to learn about the latest tools Anthropic has added to Claude Code. This section will cover everything you need to know about what commands, subagents, and hooks are and how to best make use of them.
• More Claude Code Tools: This section will cover tools to be used alongside Claude Code, such as MCP servers you can use, and how to use Claude Code outside of the terminal, specifically through Github.
• Cheat Sheet: This will include a cheat sheet of all the tips covered in this article to be easily saved and referred back to for later.

Now, let’s dive into how to use Claude Code and how to get the most out of it.

Getting started with Claude Code

Why use Claude Code?

Claude Code is no longer the only CLI Coding Agent in town. We have Gemini and Cursor which both have CLI Agents, and a host of open source ones being created. While it’s still uncertain which one will survive in the coming years, it’s clear that for now, Anthropic’s Claude Code has a major head start, and an amazing set of auxiliary tooling that is being built up around it. These tools and the tight coupling between Claude Code and the Claude Sonnet and Opus models make Claude Code an extremely powerful and useful tool. As a result, it’s worth diving into and learning how to use, as it will at the very least improve your development speed. And at the end of the day, it’s just so much fun to use.

Claude Code’s Agentic Loop

At its essence, Claude Code is a coding agent. It makes use of an agentic loop to get a task → generate a list of subtasks → execute a task → reflect on the output and either add more tasks or respond with the final output. In the end, Claude Code outputs a combination of Files, Text Output, and/or Bash Commands.

Source (Claude Code: Tips and Tricks by Anand Tyagi)

This agentic loop is what made Claude Code unique in its implementation and what made it more useful compared to other tools. However in the past few weeks, we’ve seen a host of competitors enter this space, such as Gemini CLI, Codex, and Cursor CLI. But, while this loop is no longer unique to Claude Code, it’s arguably still the best CLI Coding agent currently out there.

Setup

If you’re just starting off with Claude Code, you can follow the quickstart guide to get set up.

Claude Code lives in the terminal with both the input and output flowing through this one channel.

Beyond the terminal, Claude Code can also be attached to an IDE, which allows you to view the changes (but not edit them) within the IDE instead of through the terminal’s diff view.

Claude Code also makes use of a .claude/ directory in which all settings, commands, subagents, hooks, and future configurations live. The only other document Claude Code makes explicit use of is the CLAUDE.md files which it automatically fills into Claude Code’s context window. For existing codebases, Claude Code includes a /init command which will generate the CLAUDE.md file for the project.

With this, we have the starting point for what Claude Code is and how to get it set up. After playing around with it for a few minutes, it’s easy to see how Claude Code operates and how it will fit into your development workflow. I suggest you set it up and give it a try before implementing the recommendations from the next section.

Context Engineering for Claude Code

Context Engineering has been the hot topic of the week; but those working with Claude Code have been thinking about this for months. Unlike Cursor, which makes an index of the codebase, each Claude Code session is effectively starting as a contextless agent that has been spontaneously injected into your codebase. It heavily “abuses” the grep functionality in order to navigate the codebase and determine what it should do and where. As a result, if not thought through, the context often gets polluted with irrelevant search information.

In order to give Claude Code the right context for the task you want to accomplish, we can use the Explore, Plan, Execute, Commit framework that Anthropic recommends in their best practices guide (Anthropic: Claude Code Best Practices). Pairing this framework with the correct use of CALUDE.md files for your project, using the /resume command, the double escape operation, and the planning mode all allow you to give Claude Code the context it needs when it needs it. Let’s now cover how to best use this framework with Claude Code.

Explore

You want to start by having Claude Code “explore” the codebase by asking it to go through and read files that will be relevant to your task. At this stage, you don’t want Claude Code to start executing, so it’s best to ask it not make any changes, or, ask it to “prepare to discuss” what it plans to do (Claude Code: Tips and Tricks by Galen Ward).

Claude Code will make use of the CLAUDE.md files to better understand your codebase. I’ll cover best practices for setting up your CLAUDE.md files below, but it’s important to know that Claude Code uses these files as a first point of contact with a given folder. Writing and structuring these well can significantly improve how effectively and how easily Claude Code will understand your codebase.

Through this initial exploration process, Claude Code will have loaded the context window with all the relevant searches it made. Once this is complete, it’s time to move on to the planning phase.

Plan

Once you have the context you need loaded into your Claude Code session, you want to spend some time creating your execution plan. Anthropic explicitly recommends using words like “think”, “think hard”, “think harder”, or “ultrathink” which will directly impact how much thinking budget is allocated to Claude.

You can also use the built in Plan Mode by hitting shift+tab+tab. Plan mode will also search through the codebase for additional context, but it explicitly prevents Claude Code from making edits or running bash commands, making it a safe way to write up the plan.

After you’ve drafted up a plan that looks correct and will address your task, you’re ready to execute.

Execute & Commit

Claude Code allows you to explicitly accept every single action it takes and edit it in the case you want to closely monitor all the changes that it does. However, I’ve found that with a specific enough plan and when working on a separate branch, it’s easiest to let Claude Code work through all the changes it needs to until it reaches a stopping point that makes sense. You can toggle the Auto Accept Edits mode by clicking shift+tab or selecting the option when it first asks for explicit approval. Doing so will allow you to get to more relevant stopping points and overall speed up your development.

Claude Code recently added the ability to run bash commands in the background of the conversation. This makes it possible to give Claude Code visibility on all the output logs in the same conversation you are in, make it easier for Claude Code to debug its changes and make suggestions as you run tests. This will appear as an option when Claude Code runs a bash command.

After executing and working with Claude Code to accomplish your task, you can save and commit your work. I also recommend using Claude Code to generate your commit messages, as it does a great job of writing up all the details of the changes it made. This is useful down the line when an Agent wants to better understand past commits and gets access to a thorough commit message.

(This was a commit made by Claude Code. As you can see, it likes to take credit for its work!)

With this loop complete, let’s discuss some additional tools you can use in order to get more out of Claude Code.

Using the CLAUDE.md file

In the explore stage, Claude Code will heavily rely on CLAUDE.md files to help it understand and navigate your codebase. Claude Code will automatically load CLAUDE.md files into its context. It will always load the CLAUDE.md file in the root folder, and all CLAUDE.md files present in parent folders. When searching through sub directories, Claude Code will automatically check for the CLAUDE.md file to help it understand the subfolder’s contents.

While Claude Code’s built in /init command will generate a good starting CLAUDE.md file, I prefer to ask Claude Code to further embellish the file with more details and diagrams, or run the Analyze Codebase Command which generates a more detailed outline of your codebase which you can then add to your CLAUDE.md file.

After doing this in your root directory, it’s good practice to generate additional CLAUDE.md files in your subdirectories with more detailed specifics pertaining to that folder. For example, in a monorepo that includes both the frontend and backend, I like to have both a high level CLAUDE.md file and one for each of the two major parts of the project. This way, I can easily run Claude Code from the subdirectory, or, make larger, combined frontend and backend changes with all the context I need for both.

Here is a real example of how we might structure our high level, front end, and back end CLAUDE.md files. For this example, imagine we have the following folder structure:

root/
  frontend/
  backend/

This would go into your root/CLAUDE.md.

This would go into your frontend/CLAUDE.md.

This would go into your backend/CLAUDE.md.

You can also use # in order to add instructions to the CLAUDE.md file from within Claude Code. These can be reviewed with the /memory command.

There may be times when you want to access other directories more explicitly. In those cases, you can use the /add-dir command in order to add those directories to your current Claude Code session, which will also refer to their CLAUDE.md files as a result.

It’s important to frequently update CLAUDE.md files. Ideally, do so every time you make a PR. You can always ask Claude Code to do this for you, or use a slash command like Update CLAUDE.md in order to automate the process.

/resume command and double escape

After you’ve spent time loading up your Claude Code session with the right context, you may want to use that context to accomplish multiple tasks. Both the /resume and double escape commands allow you to revisit past Claude Code states, giving you the ability to reuse well-formed context windows and also keep your context window clean over time.

/resume or claude -resume opens up a list of past conversations which we can use to continue past sessions you were working on.

This becomes useful when you want to continue on a previous thread, want to better understand past actions, or accidentally exit out of Claude Code. You can also use it to open up multiple conversations in different shells, both of which would effectively be copies of the same conversation up until that point. Doing so splits the conversation into multiple branches, and is useful for making many small changes in parallel, all of which might require the same context.

Once we’ve already loaded the context we want, it’s also likely that we’ll want to go back and fork a conversation at a previous point. For this, we can use double escape (Esc+Esc).

This will open up all the previous points at which we prompted Claude Code, as well as actions that were taken by the agent, and allow us to hop back in time to a previous point in the conversation. Unfortunately, it won’t roll back the changes it made up until that point, but it will allow you to remove context related to tasks or searches you no longer want in your context. Effective use of this command keeps your context clean and relatively short, which increases the Claude Code’s efficacy.

Galen Ward also spoke a lot about this in his presentation.

Outside the Session

In case you want to preserve all the context you’ve gathered and don’t want to keep track of the past instances of where that context has been loaded, consider asking Claude Code to gather all the context it has and save it in multiple Markdown files. These can be saved in a top level notes/ folder, or within specific subfolders to which the notes pertain to. I like to use my CHANGELOG.md as the place where Claude Code can keep track of all the major changes I make over time, so they are easy to refer back to across branches.

Commands, Subagents, and Hooks

Claude Code’s basic functionality will get you very far. But there are a bunch of additional tools that Claude Code natively provides which can supercharge your development experience.

This bump comes from using custom slash commands, subagents, and hooks, all of which help codify the workflows that you’d want to use across sessions. Slash commands are effectively prompts that we can save in our codebase and use for repeatable tasks. Hooks give Claude Code a rule-set which makes it more secure and predictable. And subagents allow you to fire off separate workflows in parallel, all with their own context, rules, and instructions.

Put together, these tools can elevate Claude Code from a basic coding agent into a high-functioning junior developer.

Custom Slash Commands

Custom Slash Commands allow you to store and save prompts that Claude Code can use repeatedly. You can provide a set of allowed tools, like the ability to read and write to specific files and even reference files with the @ command. I use commands in order to automate things like analyzing new codebases I need to ramp up on quickly, updating my CLAUDE.md file before merging my PRs, and even allowing Claude Code within Github to run specific workflows like reviewing my code, checking for bugs, and other common tasks.

In practice, you will often use a few commands across all of your projects. It’s best to start with existing templates, and slowly tweak the commands to best fit your use case. Whenever you find yourself repeatedly executing the same prompt, consider turning it into a workflow.

The important thing to note is that slash commands are effectively prompts that get loaded into your Claude Code session. As a result, they both use and add to the context of that session. If you want to create repeatable workflows, with specific tools, goals, behaviors, and an independent context, it’s better to use subagents.

Subagents

There is some ambiguity around the difference between custom slash commands and subagents. After all, their file structure looks strikingly similar with both having tools, description, and a prompt. However, the main difference comes from the fact that subagents use their own context. As a result, it’s better to think of subagents as independent actors that work in their own context space and can be controlled and monitored in parallel from a single main thread.

Subagents should be described in terms of roles on a team. Some examples Anthropic provides in their documentation are a Code Reviewer, a Debugger, and a Data Scientist. Instead of specific tasks that you’d want executed that are better suited as a command, we should think of subagents as team members who operate in a specific way, and can handle any task we give it in the manner most appropriate to them. With subagents, you can split your current session into multiple specific ones where each agent can work on parts of a larger task in tandem, and complete the work you want to get done faster and more effectively.

While subagents and commands must be explicitly called or executed, you may also want to ensure a specific tool or process is run before, after, or during Claude Code’s execution. For this, you should use hooks.

Hooks

Hooks are shell commands that you can hard code into Claude Code’s execution workflow. If you want to run a linter after every edit, log every search made, or prevent Claude Code from ever seeing your .env files, you can use hooks in order to set those rules in place.

There are currently five event triggers: PreToolUse, PostToolUse, Notification, Stop, SubagentStop. On PreToolUse for example, you can set code that runs before any tool use: think, checking to make sure .env files are never deleted. Another example might be running a linter whenever we reach a Stop trigger. Using hooks allows you to add more structure and predictability to the Claude Code experience and is especially useful in production environments.

We can also make use of other tools in conjunction with the in-built tools that Claude Code comes with. The huge catalog of MCP servers that Claude Code has access to gives Claude Code the ability to pull in external information, navigate webpages, and more. Besides MCP servers, Claude Code also comes with a Github App that can be easily installed using the install-github-app command, which gives you the ability to use Claude Code directly from within Github. Here are some ways you can use these tools.

MCP

Claude Code can connect to any MCP server that you already use. At this point, people tend to use MCP servers for connecting their agents to their ticketing services like Linear, or their repositories with the Github MCP, but other MCP servers like Playwright are especially useful for allowing Claude Code to test its changes automatically, and continue running without too much manual intervention. Some other MCP servers that are popular include Firecrawl and Context7 which help provide context from outside the codebase to a session.

You can see an official list of MCP servers here and learn more about this aspect of Claude Code in Patrick Ellis’ presentation.

Github

Another underutilized aspect of Claude Code is the ability to use it within Github. You can set up a Claude Code integration into your codebase with the /install-github-app command and subsequently call Claude Code using @claude within Github. With this, you can go from Issue to PR all without touching an IDE. Beyond the actions that Claude Code provides out of the box, you can also write your own Github Actions that make use of Claude Code. Through this, you can automatically set up actions to perform code reviews as CI checks, automatically update documentation, and even spin up instances of your codebase in sandboxes to run automated tests against.

I personally use it to determine if there are any glaring security issues, code pattern inconsistencies, or other considerations that I might want to make before merging in the code. I also often employ it for simple fixes I don’t want to do manually or to help me create an initial commit on a new feature I want to implement.

Another way Claude Code can interface with Github is through the Github CLI. With the commands included with the gh tool, Claude Code can easily gain access to all the issues, PRs, and other repos during a session making it easy to fly through all your tasks right from the command line. The Anthropic guide also recommends using Github Worktrees, and launching an individual instance of Claude Code on each worktree in order to work on multiple tasks at once. Patrick Ellis also discusses this in his presentation.

Cheat Sheet

Below is a cheat sheet that includes information you can easily take with you from this article. Feel free to refer back to it whenever you need.

Claude Code: Tips and Tricks Cheat Sheet

Explore, Plan, Execute, Commit Framework

• Use this framework as a way of approaching larger tasks with Claude Code.
• Explore
  • Ask Claude Code to search the codebase and find information relative to your task before executing it.
  • Explicitly mention for it to “prepare to discuss” and to not change any files.
• Plan
  • Use Plan Mode by clicking shift+tab+tab or asking it to plan out what it will do before execution.
  • Spending time here will help improve performance during the execution stage.
• Execute
  • Use shift+tab to trigger the Auto Accept Edits mode and let it run more fluidly.
  • Utilize background running of bash commands to allow Claude Code to easily monitor the output logs.
• Commit
  • Commit frequently and use Claude Code to generate detailed commit messages for future use by other Agents.

CLAUDE.md file

• CLAUDE.md files are your agent’s first point of contact with a directory and should be kept up to date and include a lot of helpful information about your codebase structure.
• Use /init or the Analyze Codebase Command to generate a CLAUDE.md file.
• Keep your CLAUDE.md files updated, either manually or by using a command like Update CLAUDE.md.
• Use # to add additional memories to CLAUDE.md files.

/resume and double escape

• Use /resume to continue old Claude Code conversations. Use it in multiple shells to have parallel conversations with Claude Code using the same context.
• Use double escape (Esc+Esc) to jump back to earlier points in your conversation. Use this to also fork Claude Code sessions and repeatedly reuse well-formed context windows.

Commands, Subagents, and Hooks

• Use commands as repeatable prompts you will use in common workflows.
• Use subagents as independent agents that have their own context and can be fired off in parallel by a single main thread.
• Use hooks to better manage Claude Code’s ruleset and have code be run on explicit triggers.

MCP

• Claude Code can hook into any MCP server.
• Popular MCPs to use with Claude Code: Firecrawl, Context7, Github, Zen, browser-tools, and your issue tracker’s MCP (Jira, Linear).
• MCP Servers

Github

• Use install-github-app to add Claude Code to your Github repo.
• Utilize it in Github by tagging @claude to automatically setup PRs, review code, and anything else you’d typically tag a developer for.
• Use it within Github Actions to run it automatically during CI checks or upon certain triggers.

Final Thoughts

I hope you were able to gain some useful tips from this guide. Whether you are just getting started with Claude Code or have been using it for a while, I’d love to talk and discuss the kind of use you’re getting out of it and learn about any suggestions I may have missed.

You can find me on X and LinkedIn.
You can also join the Claude Code Commands Directory and Claude Code Subagents Directory which are directories I made to help make it easier to find and use commands and subagents for Claude Code.

Additional Links

Here are some useful links to help you learn more about Claude Code:

Claude Code Best Practices By Anthropic
Official Claude Code Documentation
Claude Code: Tips and Tricks by Anand Tyagi
Claude Code: Tips and Tricks by Patrick Ellis
Claude Code: Tips and Tricks by Galen Ward
Mastering Claude Code in 30 minutes
Claude Code: Tips and Tricks Presentation Recording Full
Master Claude Code: Proven Daily Workflows from 3 Technical Founders (Real Examples)
Claude Code Commands Directory
Claude Code Subagents Directory