Hand the general-purpose subagent the messy multi-step jobs so your main thread stays clean
Explore finds, Plan designs — general-purpose is the one that actually does. The built-in workhorse that has every tool, runs in its own context, and fans out in parallel when the work splits.
Claude Code ships with three built-in subagents, and we've covered two of them: Explore answers “where is X?” without dragging files into your thread, and Plan designs a change without touching code. The third, general-purpose, is the one that closes the loop — it has every tool (read, write, edit, bash, search) and is built for tasks that need both exploration and modification, multi-step execution, or reasoning over results that you don't want to interpret in the main window. Where Explore and Plan are deliberately read-only, general-purpose can see everything and change anything.
Why feature it now, after the read-only two. The pattern only pays off once you see the three together: Explore to find, Plan to design, general-purpose to do. The value isn't that it's more capable — it's that the capable, expensive, file-touching work happens in a separate context that reports back a summary instead of the hundred intermediate reads it took to get there. The agent's final message comes back to your main thread; the spelunking does not. That's the whole point of delegating execution and not just search.
Delegate a self-contained chore. “Use a general-purpose subagent to find every call site of the deprecated fetchUserSync helper, replace each with the async version, and update the tests.” The subagent greps, edits, runs the tests, and hands back “changed 14 files, all green” — without your main context absorbing every diff hunk along the way. You review the result, not the journey.
Fan out independent work in parallel. When you launch several general-purpose agents for unrelated tasks in a single message, they run concurrently — so three independent jobs finish in the time of the slowest, not the sum of all three. “Spawn three subagents: one to add structured logging to the auth service, one to bump the pinned dependencies in the worker, one to write the missing README for the cache module.” Three threads, three summaries back, one review pass.
Isolate risky work in a worktree. Pass isolation: "worktree" and the agent gets its own temporary git worktree — an isolated copy of the repo that's auto-cleaned if nothing changed. Use it when you want a subagent to attempt a refactor or a dependency upgrade without disturbing your working tree, then keep the result only if it's worth keeping. It's the cheapest way to run a speculative change that might not survive contact with the test suite.
The trap to avoid. general-purpose is a worker, not a planner or a search-and-stop. Because it has every tool, it's tempting to throw a vague “make the service better” at it — but an under-specified task burns its context wandering and hands back a vague summary. If you only need to locate code, use Explore; if you only need a strategy, use Plan; reserve general-purpose for a bounded job with a clear definition of done. The better your prompt names the files, the constraints, and the finish line, the less it spends finding them.
The try-it block shows the smallest version: one bounded chore, delegated, summarised back.
Drop into Claude Code at the root of a repo and delegate a bounded, self-contained job rather than doing it inline:
Use a general-purpose subagent to find every place we read the
DATABASE_URL environment variable directly, route them all through
the config module instead, and run the test suite. Report back the
list of files changed and whether tests pass.You'll get a summary back — files touched, test result — while the intermediate greps and edits stay out of your main context. To fan out, ask for several independent subagents in one message and they'll run in parallel.