Creating subagents, skills, and commands is the step you need to take to become a Claude Code power user. This is what will allow you to guide the agent and transform it from a generalist into something that's really good at your project.

The Differences

Commands are for executing repetitive actions. Things you do often and want to automate with a single command.

Skills are ways to give the agent detailed instructions about specific things. Specialized documentation that Claude can consult for particular tasks.

Agents are orchestrators of complex workflows. They can call other agents, coordinate tasks, and handle elaborate workflows.

Example: /explore

A command I use constantly is /explore. When I need to understand or load something from the codebase into context, I run:

/explore Where are authentication errors handled?

or

/explore How does the cache system work?

The command launches a subagent that searches through the code, reads the relevant files, and returns a summary of how it's implemented.

The good thing is that it consumes less context than if the main Claude did all the searching. The agent explores, synthesizes, and returns only what's important. This is key when you're working with large codebases.

Skills in Depth

Skills are markdown files that teach Claude how to do specific tasks. Unlike commands that you invoke explicitly, skills are invoked by the model.

A skill is defined in a SKILL.md file with YAML metadata and markdown content:

---
name: architecture-review
description: Reviews code changes to validate they respect
  the project's architecture. Use when doing code review
  or evaluating structural changes.
---

When reviewing architecture changes:

1. Verify that modules respect allowed dependencies
2. Check that data flows in the correct direction
3. Validate that no circular dependencies are introduced

When to use skills vs other options?

• Skills: Specialized knowledge that Claude applies automatically when relevant
• Commands: Actions that you explicitly trigger (/deploy, /test)
• CLAUDE.md: Instructions that load in every conversation
• Agents: Complex workflows that coordinate multiple tasks

Examples of useful skills

Some skills I have configured:

• commit-messages: Conventions for the project's commit messages
• error-handling: Project-specific error handling patterns
• testing-patterns: How to write tests following the team's conventions

The key is that the description is clear and has keywords that Claude can match. If the description is vague, Claude won't know when to apply it.

I usually ask Claude itself to create the skills, having a conversation to explain what I want and letting it generate the SKILL.md files automatically.

For inspiration, there are several repositories with community skills: anthropics/skills, awesome-claude-skills.

Parallelization with Subagents

One of the most powerful things about agents is that they can launch other agents in parallel using the Task tool. This allows you to divide large work into independent units that execute simultaneously.

A concrete example: when I run linters like Pronto in Rails or clang-tidy in C++, sometimes I have dozens of errors across multiple files. Instead of fixing them one by one serially, I have an orchestrator agent that:

1. Reads the linter output
2. Groups errors by file
3. Launches a subagent for each file to fix its errors

Since each file is a disjoint code unit, the agents can work in parallel without stepping on each other. What used to take several minutes fixing file by file now gets resolved in a fraction of the time.

The key is identifying work units that are independent of each other. If a change needs to touch multiple files that other agents also need to touch, you shouldn't parallelize. But for everything that is parallelizable, using Task is the way to go.

Specific, but Reusable

In general, commands, skills, and agents are super specific to each project. It's likely that each codebase has its own conventions, architecture, and needs.

But when you have similar projects that use the same frameworks, or even when team members have converged on some workflows or needs, you can package them into plugins. For my LLM-first game development experiment I defined a Claude Code plugin that I can use in several games I work on in the future.

Important Note

Everything I'm discussing applies to Claude Code, but almost all agents have similar features and if not, they can be developed on top quite easily. The idea of extending the agent with commands, specific instructions, and subagents is not exclusive to this tool.

For implementation details specific to Claude Code, I recommend the official documentation.

What's Next

With commands, skills, and agents configured, you have a system that can do a lot of work for you. But before merging any changes, you need to make sure the code is good.

Code review is where I get the most value from agents. Not just for reviewing my own changes, but to have an automated second opinion that catches things I miss.

In the next post I'll cover how I built a code review system with multiple specialized agents that review performance, security, style, and architecture.