The Latest Claude Code Features: Plan Mode, Hooks, Subagents & GitHub Actions (2026)

The basics of Claude Code are well understood. The features that separate a personal productivity boost from genuine team infrastructure are not. Plan mode, hooks, subagents, and GitHub Actions are those features — and together they change what an engineering team can safely hand to an AI agent.

Last updated: May 2026 · Covers Claude Code with Opus 4.7, Sonnet 4.6, Haiku 4.5

Contents

• Why these four features matter
• Plan mode: look before you leap
• Hooks: rules enforced, not requested
• Subagents: a team in a terminal
• GitHub Actions: Claude in your pipeline
• What else shipped in May 2026
• How they compose into infrastructure
• Frequently asked questions

Why these four features matter

Configuration changes what an agent can access, how work is reviewed and where it must stop. A new user runs Claude Code like a faster autocomplete. A team that has internalised these four features runs it like a governed member of staff — one that plans before acting, follows the house rules without being reminded, delegates focused work to specialists, and shows up inside the tools the team already uses.

Access and usage costs depend on the product and plan. Your competitor can download them this afternoon. The edge was never the tool; it is the hour you spend teaching it your rules, and most people stay too busy to sit still and spend it.

If you are new to the tool itself, start with What Is Claude Code? and How to Install Claude Code. This piece assumes you have it running and want to know what the serious teams are actually using.

Plan mode: look before you leap

Plan mode asks Claude Code to investigate and present an approach before implementation. It can write its plan file, and configured hooks still need review. Use filesystem and tool permissions where you need an enforceable no-write boundary.

In normal operation, Claude Code reads what it needs, makes the change, and shows you the diff. That is the right loop for well-scoped tasks. But for anything large, ambiguous, or risky (a cross-cutting refactor, a change to unfamiliar code, a task where the approach matters more than the typing), you want to agree the strategy before any file is touched.

That is plan mode. Claude investigates the codebase, works out how it would approach the task, and returns a written plan: what it will change, in what order, and why. Nothing is edited until you say go. You read the plan, correct the misunderstanding ("no — don't touch the legacy adapter, we're deprecating it"), and only then approve execution.

The value is caught mistakes. A wrong approach spotted in a plan costs thirty seconds to redirect. The same wrong approach discovered after Claude has edited fifteen files costs a confusing review and a revert. For senior engineers handing Claude Code the work they would normally scope themselves, plan mode is the feature that makes delegation feel safe.

Where it earns its keep: onboarding Claude to an unfamiliar codebase, any refactor that spans more than a couple of files, and any task where you would have wanted a junior to "talk me through your plan before you start."

Hooks: rules enforced, not requested

Hooks run your own shell commands automatically at defined points in Claude's lifecycle — allowing specific checks to run outside the model’s prose. A CLAUDE.md file asks Claude to follow your conventions. A correctly configured hook can enforce a specific boundary.

Hooks fire on lifecycle events. The ones teams use most:

• `PreToolUse` — before Claude runs a tool. Use it to block forbidden actions: reject any edit to a protected path, refuse a dangerous command before it runs.
• `PostToolUse` — after a tool runs. Use it to react: run the linter and formatter after every edit, log the change to an audit file.
• `UserPromptSubmit` — when you send a message. Use it to inject context or enforce input rules.
• `Stop` — when Claude finishes a task. Use it to run the test suite before the work is allowed to be called "done."
• `SessionStart` — when a session begins. Use it to load fresh context, like the current ticket or environment state.

A hook is only as reliable as its configuration and implementation. Test the event, matcher, exit behaviour and failure path. A timeout or unexpected command result must not silently turn a required check into an optional one. Official hooks reference.

A hook can contribute to a control, but it does not establish compliance for the whole system. Keep permissions and independent review in place.

Subagents: a team in a terminal

A subagent is a specialised Claude instance with its own context window, its own scoped tools, and its own system prompt — that your main Claude session delegates focused work to. It is how one operator supervises what amounts to a small team.

The mechanics are simple. You define a subagent — a file in .claude/agents/ with a name, a description of when it should be used, and the tools it is allowed to touch. When Claude hits a task that matches the description, it delegates: the subagent does the work in its own context window and returns only the result. Four benefits follow, and they are not subtle:

• Context stays clean. A research task that would flood your main conversation with file contents and logs happens in the subagent's window instead. Your main session keeps its focus — which directly improves the quality of its work, because context bloat is one of the most reliable ways to degrade an agent.
• Tools stay scoped. A documentation subagent gets read-only tools. A test-writer gets the test runner. Constraint is configured, not trusted.
• Specialisation is testable. Compare a focused prompt with the general workflow on the same tasks.
• Cost can change. You can route a subagent to a cheaper, faster model — sending high-volume, low-stakes work to Haiku 4.5 while the main session runs on Sonnet or Opus. This is model routing applied inside a single session.

For example, a team could separate code review, test design and documentation research. This is an illustrative division of work, not a measured client result. Compare it with a single session before assuming the additional coordination is worthwhile.

GitHub Actions: Claude in your pipeline

Claude Code runs inside GitHub Actions, which means it lives where your team already works: in pull requests and issues. Mention `@claude` and it goes to work. This is the feature that takes Claude Code off individual laptops and into the shared workflow.

Setup is genuinely a few minutes. From your terminal, run /install-github-app — it walks you through installing the GitHub app and storing your ANTHROPIC_API_KEY (how to get one) as a repository secret. From then on, the action (anthropics/claude-code-action@v1) responds to @claude mentions:

text@claude implement this feature based on the issue description
@claude how should I implement authentication for this endpoint?
@claude fix the TypeError in the user dashboard component

Claude reads the context (the issue, the PR, your CLAUDE.md standards) and acts: it opens a complete pull request, reviews a colleague's code, answers a design question, or fixes a bug, then pushes the change for human review. It runs on GitHub's own runners, while model processing depends on the configured provider and its terms, and it follows the same CLAUDE.md guidelines your local sessions do.

A few specifics worth knowing. The action defaults to Sonnet — to put your hardest CI work on the frontier model, set --model claude-opus-4-7 in the configuration. You can run it two ways: interactively, responding to @claude mentions, or as automation, running a fixed prompt on a schedule or trigger (a nightly "summarise yesterday's commits and open issues", an automatic review on every new PR). And — a useful detail for the next article in this series — the Claude Code action uses the Claude Agent SDK, the same library that lets you build Claude Code into anything.

The practical effect for a UK team: the boring-but-important work that slips between sprints (reviewing every PR, triaging incoming issues, keeping dependencies current) can run automatically, in the open, with every action visible in the PR history.

What else shipped in May 2026

These four features are the load-bearing ones — but Claude Code has not stood still, and a roundup of the newest arrivals is the honest way to answer "what's the latest." As of late May 2026, the additions worth knowing:

• Agent view (`claude agents`) — one screen showing every running Claude Code session: what is working, what is blocked on you, what is done. The control room for a team running several agents at once.
• `/goal` — keeps Claude working across turns until a completion condition holds, instead of stopping after each step. You set the outcome; it keeps going until it gets there.
• Routines — scheduled cloud agents that fire from a timer, a GitHub event, or an API call. The bridge from "Claude Code when I run it" to "Claude Code on a schedule."
• `/ultrareview` — a fleet of bug-hunting agents runs a deep code review in the cloud and lands the findings back in your terminal, useful in CI as much as locally.
• `xhigh` effort and the `/effort` slider — dial how hard Opus 4.7 thinks, with xhigh now the recommended setting for serious coding. Fast mode now defaults to Opus 4.7 too.
• Auto mode — uses a classifier to handle permission decisions. It can make mistakes; it is not proof that every permitted action is safe. Keep consequential operations behind explicit controls.

The direction of travel is consistent across all of them: from a tool you drive one command at a time towards infrastructure that runs on goals, schedules, and policies. The four features above are exactly how you put the guardrails in place before you hand an agent that much autonomy.

How they compose into infrastructure

Used alone, each feature is handy. Used together, they turn Claude Code into a governed system you can trust with real work. Picture the composite: a task arrives as a GitHub issue. The GitHub Action picks it up. Claude enters plan mode, proposes an approach, and a human approves. It delegates the research to a read-only subagent running on Haiku to keep costs and context lean. As it works, hooks run the linter after every edit and the test suite before the work can complete. The finished change arrives as a pull request for human review.

That is an illustrative integration, not a description of Ampliflow’s release setup. The broader ideas — scoped tools, review and tested controls — also matter when evaluating Amplex, the public Cellbot case study or Hermes Agent.

Frequently asked questions

What is plan mode in Claude Code?

Plan mode asks Claude to investigate and propose before implementation. It is not a sandbox: plan-file writes and configured hooks need consideration, and stronger restrictions should be enforced through tool and filesystem permissions.

What are Claude Code hooks used for?

Hooks are your own shell commands that run automatically at lifecycle points — before a tool runs (PreToolUse), after it runs (PostToolUse), when you submit a prompt (UserPromptSubmit), when a task finishes (Stop), and when a session starts (SessionStart). They can enforce specific checks when configured and tested: run the linter after every edit, run tests before a task can be marked done, or block edits to protected files. For regulated businesses, they are enforced controls you can demonstrate, not hope for.

What is a Claude Code subagent?

A subagent is a specialised Claude instance with its own context window, scoped tools, and system prompt, defined in .claude/agents/. Your main session delegates focused tasks to it; it works independently and returns only the result. Subagents keep your main context clean, enforce tool constraints, specialise behaviour, and can run on cheaper models like Haiku to control cost.

How do I use Claude Code with GitHub Actions?

Run /install-github-app from the Claude Code terminal to install the GitHub app and store your ANTHROPIC_API_KEY as a repository secret. The action (anthropics/claude-code-action@v1) then responds to @claude mentions in issues and pull requests — opening PRs, reviewing code, fixing bugs — or runs automatically on a trigger. It defaults to Sonnet; set --model claude-opus-4-7 for your hardest work.

Do these features cost extra?

The features themselves are part of Claude Code — there is no separate charge for plan mode, hooks, subagents, or the GitHub Action. You pay for the model usage they consume (via your subscription or API key) and, for GitHub Actions, the GitHub-hosted runner minutes they use. Routing subagents to Haiku is a way to reduce the model cost of a given workflow.

Are these features only for developers?

Plan mode, subagents, and hooks are most powerful in engineering work, but the underlying patterns — propose before acting, delegate to specialists, enforce rules deterministically — apply to any structured automation. Non-developers more often access this power through a configured system someone technical has set up, rather than wiring it themselves. See Claude Code for non-developers for that angle.

Related reading

• ↔ The Claude Agent SDK: Building Production Agents — the library these features are built on, for when you want to go beyond the CLI
• ↔ Claude Models Explained: Fable, Opus, Sonnet and Haiku — which model to route each subagent and CI job to
• ↔ What Is MCP (Model Context Protocol)? — how Claude Code connects to your databases, APIs, and tools
• ↔ Claude Code Skills — Write, Share, Govern at Scale — the companion capability that packages reusable expertise
• ↔ What Is Claude Code? A UK Business Guide — the foundational explainer, if you are starting from scratch

What should you do next?

Plan mode, hooks and subagents address different parts of a development workflow. Their value depends on the task and the controls around it.

Start with the recurring failure or delay. Define what a successful result looks like before adding another automated step.

Explore business automation →

Configuration compounds. The hooks you write and the subagents you scope this month keep paying out every day after.

Ampliflow is an agency based in Solihull, West Midlands, building websites, business software and automation for UK businesses.