Claude Code Subagent Prompts That Actually Orchestrate

Spawn one subagent per file in this list and have each review ONLY its file for bugs, unhandled errors, and dead code. Each returns a short list of findings with line numbers, nothing else. Do not let them edit anything. When they all finish, merge the findings into one deduplicated list ranked by severity, then wait for my go before fixing.

The single biggest speed win: N files reviewed at once instead of one long serial pass, with a clean merge step so you get one ranked list, not N scattered ones.

Research this question with 3 subagents in parallel, each from a different angle: one reads the official docs, one searches real-world code and issues, one looks for the failure modes and gotchas. Each returns a tight summary with sources. Then you synthesize the three into one answer and flag anything the three disagree on.

Three blind researchers beat one, because each is forced down a lane it would skip on its own, and the disagreements are exactly where the real answer hides.

Have 2 subagents each independently implement this function to the same spec, without seeing each other's work. Then you compare the two, take the clearer/safer one as the base, and graft any better idea from the other. Show me the diff and one line on why you chose what you chose.

A cheap tournament: two attempts from a blank slate almost always surface an approach a single pass would miss, and picking-plus-grafting beats iterating one guess.

You just produced a set of findings. Now spawn a subagent whose ONLY job is to try to REFUTE each one. Tell it to default to 'this is wrong' unless the evidence is undeniable, and to show the exact code or output that proves or kills each finding. Drop every finding it refutes.

The fastest way to stop plausible-but-wrong output: a skeptic that gets rewarded for tearing your work down, not agreeing with it.

Hand this finished work to a fresh subagent that has NOT seen our conversation. Give it only the original requirements and the result. Ask it: does this meet every requirement, what is missing, and what would a strict reviewer reject? Fix only what it flags.

Context poisons judgment. A grader that never watched you build it catches the gaps you have gone blind to.

When you delegate to a subagent, tell it its final message is the ONLY thing that comes back to you, so it must return a tight structured result (a list, a verdict, a diff) and NOT its play-by-play. You keep the conclusion, not the transcript.

The orchestrator's context is precious. Subagents that return raw logs blow it up; subagents that return conclusions keep you sharp across a long run.

Give each subagent exactly one narrow job and one output shape. If a task has three parts, that is three agents, not one agent doing three things. Name the job in the first line of the prompt so the agent cannot drift.

Narrow agents are reliable agents. The moment one agent owns three goals, it half-does all three; one-job agents finish.