Claude Code 67% Faster: Fork Subagents & Ultrareview

Anthropic shipped over 50 improvements to Claude Code this week, and the biggest one is hard to miss: the /resume command is now 67% faster on large sessions (files over 40MB). If you've been waiting 30 seconds to pick up where you left off, that wait just got cut by two-thirds. But speed is only part of the story — this changelog also introduces fork subagents, a new /ultrareview skill, and auto mode for Opus 4.7, marking a clear shift from coding assistant to autonomous agent platform.

Claude Code /resume: 67% Speed Fix for Large Sessions

If you've been building with Claude Code for months, your sessions accumulate fast. Every file read, every bash command, every code change gets logged. By the time you're deep into a complex refactor, sessions can hit 40MB or more — and resuming them used to mean watching a progress bar crawl while Claude re-read its entire history.

That experience is now 67% shorter. Anthropic engineered a new /resume path that handles large sessions without reprocessing every token from scratch, and added a companion behavior: when a session is stale and large, Claude now offers to summarize it before re-reading (a technique where a long conversation history gets condensed into a shorter, usable snapshot — similar to how a good meeting recap replaces reading every email thread you missed).

Other session-related fixes shipping alongside the speed improvement:

• Stalled subagents (child AI processes that get stuck mid-execution) now fail cleanly after 10 minutes with a clear error message — previously, they hung silently until you manually killed the process
• A bug that caused incorrect computation of the 200K context window (the maximum amount of text Claude can consider at once) has been fixed
• Opus 4.7 now correctly utilizes its full 1M-token native context window

Fork Subagents — Claude Code Runs Multiple AI Workers at Once

The most architecturally significant change in this release is the arrival of fork subagents. In plain terms: when Claude is working on a task, it can now spin up independent child processes (subagents — specialized copies of itself focused on a narrower piece of work) that run in parallel without blocking the main agent session.

Previously, multi-agent workflows required custom wrapper scripts or external orchestration layers. Now you enable it with one line:

export CLAUDE_CODE_FORK_SUBAGENT=1

The workload model mirrors how large engineering teams operate. Instead of one developer reading every file sequentially, Claude can send one subagent to audit security, another to check test coverage, and a third to analyze performance — all simultaneously. For enterprise teams, this connects to another improvement: mcpServers are now loaded for main-thread agent sessions via the --agent flag, which means MCP servers (external tool connectors — things like database access, API integrations, or Slack notifications that Claude can call autonomously) are available to forked child agents from the very start of a session.

Stalled subagent handling also improved significantly: previously, a frozen child process would hang silently with no feedback. Now it fails with a descriptive error after exactly 10 minutes, so you know immediately what broke and why.

Two New Skills That Change Daily Workflow

/ultrareview — Automatic Parallel Code Analysis, Free for Subscribers

/ultrareview runs a comprehensive code check using parallel multi-agent execution (multiple AI agents working simultaneously, each examining different sections of your codebase). This is the type of analysis that would take a senior engineer several hours — Claude Code completes it automatically across your entire project in minutes.

Run it before opening a pull request, or after a major refactor, to surface issues without manually specifying what to check:

/ultrareview

The skill ships free for subscribers in this release with no additional configuration needed. Compare that to GitHub Copilot's code review, which requires manual review requests and sequential reading — /ultrareview runs agents across your whole codebase at once and returns a consolidated report.

/less-permission-prompts — Fewer Interruptions, Same Security

One of the biggest daily friction points in Claude Code is the constant stream of permission prompts — every file read and search command triggers a confirmation request. The new /less-permission-prompts skill scans your session transcripts (the full logs of everything Claude has done across your project) and automatically proposes prioritized allowlists for safe, read-only operations, letting you approve categories of actions in bulk rather than one at a time. Write operations and sensitive paths still require explicit approval — the security boundary doesn't move, just the noise level drops.

Opus 4.7 Gets a New Effort Gear — Auto Mode Now Free for Max

Anthropic added a new effort level called xhigh, positioned between high and max in the compute-intensity scale. Effort levels (settings that control how much processing power Claude applies to a problem — higher effort means slower but more thorough responses) now span four tiers: medium, high, xhigh, max.

More practically for subscribers: auto mode for Opus 4.7 is now available to all Max plan users without needing the experimental --enable-auto-mode flag. Claude automatically selects the appropriate effort level based on task complexity — routine questions get fast answers, while architectural decisions or security audits get the full reasoning treatment. You can also set it manually with the interactive slider:

/effort

OpenTelemetry events (an open standard for collecting performance and compliance audit data from running applications — essential for enterprise teams tracking model behavior) now include effort attributes when the model supports them, making it easier to monitor and audit how Claude Code applies compute across different task types.

50+ Other Fixes Worth Knowing

Beyond the headline features, the changelog delivers practical improvements across every layer of the tool:

• Plan files now named after your prompt — instead of random words, files are named like fix-auth-race-snug-otter.md, making multi-session work far easier to track
• PowerShell tool rolling out on Windows — enable on Linux and macOS now with CLAUDE_CODE_USE_POWERSHELL_TOOL=1
• Built-in fast search — native macOS and Linux builds now embed bfs (a breadth-first filesystem search tool) and ugrep (a high-speed text search utility) directly, cutting the round-trip delay of calling external tools for every file lookup
• Long URLs stay clickable — via OSC 8 hyperlinks (a terminal protocol that keeps URLs clickable even when they wrap across multiple lines in output), bash output links no longer break mid-line
• Security hardening — /private/{etc,var,tmp,home} paths on macOS are now flagged as dangerous under bash removal rules, reducing accidental system file exposure
• Plugin auto-resolution — missing plugin dependencies install automatically from configured marketplaces instead of requiring manual intervention
• Model selection persists across restarts, even when the project configuration pins a different model
• WebFetch fixed for very large HTML pages — input is now truncated before conversion, preventing failures on heavyweight documentation pages

From Coding Assistant to Autonomous Agent Platform

Taken together, these changes tell a clear story about where Anthropic is steering Claude Code. Fork subagents, MCP server integration at agent startup, OpenTelemetry audit logging, and security hardening aren't the feature list of a chat-based coding assistant. They're the infrastructure of a platform designed to run autonomously on real engineering workflows — spawning specialized agents, logging behavior for compliance teams, and managing its own resource limits without constant developer input.

GitHub Copilot and Cursor are still primarily reactive tools that wait for prompts. Claude Code is increasingly designed to orchestrate at the workflow level. For developers and teams already using it — or just getting started with Claude Code for AI automation — the immediate wins are concrete: sessions resume faster, code analysis runs automatically before every PR, and permission friction drops. Update Claude Code now and run /ultrareview on your next project — parallel agent analysis typically surfaces issues in under five minutes that a solo engineer would spend hours finding manually.

# Check your installed version
claude --version

# Try the new commands immediately
/resume                          # 67% faster on sessions 40MB+
/ultrareview                     # Parallel multi-agent code analysis
/less-permission-prompts         # Bulk-approve read-only operations
/effort                          # Interactive effort level selector

# Enable new features via environment
export CLAUDE_CODE_FORK_SUBAGENT=1       # Fork subagents on external builds
export CLAUDE_CODE_USE_POWERSHELL_TOOL=1 # PowerShell tool on Linux/macOS

New to Claude Code or looking to get more out of autonomous sessions? The AI for Automation guides walk through setup and real-world developer workflows from first install to full agent orchestration.

Related Content — Get Started | Guides | More News