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

The gap between teams getting 10% from Claude Code and teams getting 60% is almost never the model. It is the configuration. 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.

The tools are free, though. 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 tells Claude Code to research the task and present a plan (without making a single change) and then waits for your approval before it executes. It is the difference between "off you go" and "show me your working first."

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 — turning project rules from polite requests into deterministic guarantees. A CLAUDE.md file asks Claude to follow your conventions. A hook makes it.

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.

The shift this creates is from vibes to verification. Consider a UK SaaS team with a rule that the test suite must pass before any task is complete. Written in CLAUDE.md, that rule is followed most of the time. Wired as a Stop hook that runs npm test and refuses completion on failure, it is followed every time, by construction. The model cannot forget a hook the way it can occasionally drift from an instruction.

This is also where compliance lives. A PreToolUse hook that blocks edits to a payments module, or refuses to read a secrets file, is an enforced control you can show an auditor — not a hope. For regulated UK businesses, that distinction is the whole ballgame.

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 improves results. A focused system prompt for one job outperforms a generalist trying to hold everything at once.
• Cost drops. 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.

A 40-person UK retail platform we work with runs a standing set of subagents: one for code review, one for writing tests, one for investigating partner-API documentation. The main session orchestrates; the specialists execute. The result is throughput that a single un-delegated session cannot match, because the work is parallelised across focused contexts instead of crammed into one.

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, so your code stays on GitHub's infrastructure, 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 — GitHub Actions is itself built on top of 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 — a classifier handles routine permission prompts so safe actions run uninterrupted and risky ones are blocked: the sensible middle ground between approving everything and skipping permissions entirely.

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.

No single feature did that. The composition did. This is exactly the principle behind Amplex, our agentic orchestration framework (specialist harnesses, enforced guardrails, and reviewing-model verification), and it is how the same discipline runs under Cellbot and the operational automation in Hermes Agent. The tools are off-the-shelf. The reliability comes from how you wire them together.

Frequently asked questions

What is plan mode in Claude Code?

Plan mode tells Claude Code to investigate a task and present a written plan — what it will change and why — without editing any files, then wait for your approval before executing. It is the safe way to hand Claude large, ambiguous, or risky tasks: you agree the approach before any change is made, so wrong approaches are caught in seconds rather than after fifteen files have been edited.

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 turn project rules from requests into guarantees: 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: Opus 4.7 vs Sonnet 4.6 vs Haiku 4.5 — 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?

The teams that get 60% out of Claude Code are not using a better model than you. They have configured plan mode, hooks, subagents, and CI integration into a system that plans, enforces, delegates, and reviews — automatically.

That configuration is most of the value, and it is the part we set up for UK teams every week. We design the harnesses, write the hooks, scope the subagents, and wire the pipeline so Claude Code behaves like governed infrastructure rather than a clever toy.

See how Ampliflow runs Claude Code in production →

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

Ampliflow is a UK AI frontier lab and growth agency based in Solihull, West Midlands. We ship production AI systems for UK SMEs and enterprises using Claude Code, the Amplex orchestration framework, and reviewing-model verification. Our case studies are named, our methodology is published, and our team builds with Claude Code daily.