Impressive Claude Code Features

I’ve been spending some time exploring Claude Code at work, and a few features stood out to me, so I wanted to share.

Individually they may seem small, but together I think they can really change how we work with agents.

Number One : Hooks

Hooks are probably the most important feature to discover. They let you run logic at different points in the agent life-cycle. I’ve included an image of this life-cycle below, for the curious.

Hooks let you have Claude run plugins, skills, agents, or commands at key points in its life-cycle. Like when a channel event triggers, or when a session starts, before/after a tool runs, or when the agent stops.

These are just a few examples. When combined with Channels (which I describe later), you can build almost anything. They are grouped into categories, here are a few of my favourite categories:

Agent Hooks

Agent hooks spin up another agent in response to a lifecycle event. You can chain agents together for tree of thoughtstyle reasoning, or build very complex specialist workflows, and manage context independently per agent.

Stop hooks

Stop hooks run after the agent finishes. So you can use them to run tests, lint code, check for edge cases, or send events or notifications.

If something fails, you can trigger follow-up actions automatically. They remove a lot of manual “ok now run …" steps.

Hook Matchers

Hook Matchers extend hooks, to make them even more useful, you can selectively filter life-cycle events using regex matchers to trigger your hooks. e.g.:

• Bash → only intercept shell commands (For PostToolUse events)
• Edit|Write → run the hook on file changes (For PostToolUse events)
• mcp__.* → run the hook on MCP tools (For Elicitation events)

This can help you keep hook triggers targeted instead of global. Hook Matchers let you express this in a really elegant way.

Hooks Are Composable

Once you start using hook matchers, hooks stop being one big system and become small, focused pieces that can be composed. An example pipeline might look like:

• one hook for logging Bash
• one hook for validating Edit|Write
• one hook for guarding mcp__.*

Each one does a single job. Matchers are a small detail, but they’re really elegant and useful once you get familiar with Claude life-cycle events.

Number Two : Channels

Channels are my next favourite feature, it provides a way to push events into a running Claude session. Channels can be one-way, or two-way. A one-way channel can handle things like alerts, webhooks, chat-nontifications, AWS events, PagerDuty alerts, you name it :)

With Channels external systems can now send events to the agents. Two-way channels even allow Claude to reply to the events, so you can build things where Claude agents react to events happening elsewhere. (I’ll bet there is an opportunity to integrate with other A2A systems using Channels)

Number Three : Scheduled tasks (/loop and /schedule)

This feature is overlooked I find, but you can have Claude run prompts, commands, skills, and agents on an interval. Its documented here.

These are session-scoped, so they disappear when the session ends, but you can make them persistent by using Claude Desktop, or Claude Code Github Actions.

Loops are related to scheduled tasks, you can run a skill/agent a number of times using the Loop Over Command.

Runner-Up Prizes Go To…

While hooks, channels, and schedules are my favourite features, there are others that may be overlooked that are also impressive.

Worktrees

Claude Code has exceptional support for Git worktrees, they are really useful if you need to have multiple agents working in parallel on different tasks in the same repo.

Each agent works in its own isolated directory, but everything is still part of the same project. I’ve found this is especially useful when you’re doing larger changes that can be split up. You can read more about them here.

Batch

/batch lets you fan out and work across hundreds (even thousands of) of agents if your token budget and computer can handle it.

Instead of doing things sequentially, you can parallelize using batch. I can see this being incredibly useful for migrations, porting code, or anything repetitive.

I haven’t used it much because I’m afraid of the Anthropic bill :), nonetheless its documented here

Custom Agents

This is kind of similar in a way to custom skills and plugins, You can define custom agents with their own system prompt and tools, and then you can run them with:

claude --agent=<name>

This makes it easier to specialise behaviour instead of re-prompting every time. So your personal collection of Agent minions can accumulate over time :).

Add-dir

If you are mid session, and you need to pull a different project or set of files into your context, you can give Claude access to additional directories using the /add-dir command.

Bare mode

If you are in a hurry, --bare skips loading local configs and speeds up startup. Its useful for non-interactive or scripted usage where you want full control over what’s loaded.

Remote control and teleport

You can move sessions between environments or control them remotely using teleport. I haven’t used this much beyond simple experiments. But it seems quite powerful, and maybe something that could be combined with Channels.

My Takeaway From It All

Hooks allow you to compose complex automated systems.
Scheduling and channels allow you to add reactivity.
Worktrees and batch give you scale and the ability to work safely at scale.

That combination is where Claude Code starts to feel different from a typical AI coding agent, and more like an agentic platform you can build real systems on.

That’s all I’ve got friends 🙂