What in the World are Subagents?

Creating Your First Subagent: A Step-by-Step Vibe

1. Open the Subagent Interface: In your Claude Code terminal, just type
   1 /agents
   . This will bring up the subagent management screen.
2. Create a New Agent: You'll see an option to "Create New Agent." You can choose to make it a "project-level" agent (only for your current project) or a "user-level" agent (available in all your projects). I’d recommend starting with project-level agents to keep things organized.
3. Let Claude Do the Heavy Lifting: You can manually set up your agent, but the coolest way is to "Generate with Claude." You just describe what you want the agent to do, & Claude will write the system prompt & configure it for you.
4. Define its Role: Be as comprehensive as you can in your description. For example, you could say: "An agent that specializes in writing unit tests for my React components using Jest & React Testing Library."
5. Configure Tools: This is a SUPER important step. You can give your subagent access to all your tools, or you can be selective. For a testing agent, you might only give it read-only access to the code & the ability to run testing commands.
6. Save & You're Done!: Claude will show you the markup file it created for your new agent. Just save it, & your new subagent is ready to go!

Practical Examples of Subagents You Can Create Today

• The Code Reviewer: This is a classic. You can create a subagent that's an expert in your team's coding style guide. It can automatically review your code for style violations, potential bugs, & areas for improvement.
• The Documentation Writer: Hate writing docs? Same. Create a subagent that can read your code & generate documentation for it. You can even train it to follow a specific documentation format like JSDoc or reStructuredText.
• The Database Guru: This subagent is an expert in SQL. You can give it access to your database schema & have it write complex queries, optimize existing ones, or even design new tables for you.
• The Frontend Specialist: Got a favorite frontend framework? Create a subagent that's an expert in it. Whether it's React, Vue, or Svelte, this agent can help you build components, follow best practices, & troubleshoot framework-specific issues.
• The Legacy Code Modernizer: This is a more advanced one. You can create a subagent to help you refactor old code. It can identify outdated patterns, suggest modern alternatives, & even help you migrate from an old framework to a new one.
• The Security Analyst: This subagent is your personal security expert. It can scan your code for common vulnerabilities, check for insecure dependencies, & suggest ways to make your application more secure.

Best Practices for Juggling Your Subagent Team

• Keep them focused: It's better to have several subagents with single, clear responsibilities than one subagent that tries to do everything. This makes them more predictable & performant.
• Write detailed prompts: The more specific you are in your instructions, the better your subagent will perform. Include examples & constraints to guide its behavior.
• Be smart about tool access: Only give subagents the tools they absolutely need. This improves security & helps them focus on the task at hand.
• Use version control: Check your project-level subagents into Git. This way, your whole team can use them, contribute to them, & keep them consistent.
• Manage their memory: Remember, each subagent has its own context. This is great for focus, but it can also lead to information silos. A really interesting idea is to have a "memory" subagent whose sole job is to search past conversations & provide relevant context to other subagents. This can help your team of agents "learn" from past work.

Getting Hooked on Claude Code Hooks

The Different Types of Hooks

• PreToolUse: This runs before Claude uses a tool. This is your chance to do things like validate code, check for permissions, or even block the tool from running altogether.
• PostToolUse: This runs after a tool has been used successfully. It's perfect for things like auto-formatting code, running tests, or updating documentation.
• Notification: This runs whenever Claude sends a notification, like when it needs your input. You could use this to send yourself a desktop notification so you don't miss anything.
• Stop: This runs when Claude finishes generating a response. Great for cleanup tasks.
• Subagent Stop: This runs when a subagent finishes its task.

How to Set Up Your First Hook

1. Open the Hooks Configuration: Type
   1 /hooks
   in the Claude Code terminal.
2. Choose an Event: Select the event you want to hook into, for example,
   1 PreToolUse
   .
3. Add a Matcher: This is how you tell the hook when to run. You can match based on the tool name. For example, you could use
   1 Write|Edit|MultiEdit
   to run the hook whenever Claude tries to write or edit a file. You can also use
   1 *
   to match all tools.
4. Create the Hook Command: This is the shell command you want to run. For example, if you're setting up a pre-commit hook, your command might be a script that runs your linter & tests.
5. Save Your Configuration: You can save the hook at the user level (for all projects) or the project level.

Real-World Hook Examples to Automate Your Life

• Automatic Code Formatting: This is a must-have. Set up a
  1 PostToolUse
  hook that runs a formatter like Prettier or Black on any file that Claude edits.
• Pre-Commit Sanity Checks: Use a
  1 PreToolUse
  hook to run a script that checks for things like API keys or other secrets before Claude is allowed to make a commit.
• Chained Hooks for Complex Workflows: While Claude doesn't have a built-in way to chain hooks in a sequence, you can achieve this by having your hook command call a script that runs multiple commands in order. For example, you could have a single script that first formats the code, then runs the linter, & then runs the tests.
• Custom Notifications: Tired of missing Claude's requests for input? Set up a
  1 Notification
  hook that uses a command-line tool to send a push notification to your phone or desktop.
• Intelligent Git Commits: This is a really cool one I saw. You can set up a series of hooks that automatically create a "checkpoint" commit after every file change. Then, when you're done with a task, a
  1 Stop
  hook can squash all those checkpoint commits into a single, meaningful commit.

Tips for Mastering Hooks

• Start Simple: Don't try to build a super complex, multi-stage hook workflow from day one. Start with a simple formatting hook, get comfortable with how it works, & then gradually add more complexity.
• Test Your Commands: Before you put a command in a hook, run it directly in your terminal to make sure it works as expected. Trust me, it'll save you a lot of headaches.
• Use the
  1 matcher
  Wisely: Be specific with your matchers to avoid running hooks when you don't want to. You can use simple strings, or even regex for more complex matching.
• Keep Your
  1 settings.json
  Clean: For more complex hooks, it's a good idea to put the logic in an external script rather than trying to cram a bunch of shell commands into your
  1 settings.json
  file. This makes your hooks easier to read, debug, & maintain.

Tying It All Together