---
title: "Claude Code Subagents: A Researcher, Writer and Checker Team Checked"
date: "2026-11-12"
video_id: "7707347441095331086"
tiktok_url: "https://www.tiktok.com/@pro.glitch/video/7707347441095331086"
creator: "@pro.glitch"
category: "Coding"
tags: ["claude code", "subagents", "multi-agent systems", "auto mode", "anthropic"]
excerpt: "A researcher, writer and checker team in Claude Code matches Anthropic's guidance on token cost and verifiers. Where the video overstates what Anthropic says."
---
Professor Glitch (@pro.glitch) proposes a three-agent Claude Code team: a researcher that writes a facts page, a writer that drafts from it, and a checker with a written checklist. Most of the reasoning matches Anthropic's January 2026 article on multi-agent systems, including the 3 to 10 times token cost and the risk of a checker that passes work too easily. The video overstates Anthropic's position on file handoffs, and several of its product claims have no source.

## Why not five agents named by job title?

The video warns against "5 BOTS NAMED BY JOB TITLE" all talking to each other. It says "Anthropic tested that kind of setup. It lost context at every handoff and spent more tokens coordinating than working," and "Teams of agents can use three to 10 times the tokens for the same job."

Anthropic's article "Building multi-agent systems: When and how to use them," dated January 23, 2026, supports all three points. It says multi-agent implementations "typically use 3-10x more tokens than single-agent approaches for equivalent tasks." It describes teams that "suffered from lost context at each handoff," and an experiment with role-based agents in which subagents spent more tokens on coordination than on the work.

Anthropic's June 13, 2025 research-system post gives different numbers (about 4 times the tokens of chat for agents, about 15 times for multi-agent systems). Those are measured against chat, not a single agent, so they should not be mixed with the 3 to 10 times figure.

## The three-agent setup

The video's alternative is to split agents by what they read, not by job title. A skill file shown on screen runs them in order:

1. The researcher saves a facts page per client to `handoff/`.
2. The writer reads the facts page and saves a draft to `handoff/`.
3. The checker reviews the draft. Failures go back to the writer, up to two rounds. If it still fails, the draft moves to `review/` with a flag.

## Does Anthropic recommend file handoffs?

Not in the article the video cites. The video says "Anthropic recommends exactly that, so nothing gets lost in a game of telephone," referring to handoffs through files in a shared folder. The January 2026 article uses the telephone-game image for information degrading across handoffs, but it does not discuss files as the handoff method.

The closer match is the June 2025 post, which describes subagents that store work externally and pass "lightweight references" back to the coordinator. That shows Anthropic has used pointer handoffs, which is weaker than a recommendation.

## Does a Claude Code subagent start blank?

Mostly. The video says "a sub agent starts blank. It doesn't see your chat," so its instructions must go in its job file or on the page it receives. The Claude Code subagents documentation says subagents "don't see the parent conversation by default" and start with a fresh context window.

"Blank" is slightly too strong. A regular subagent starts with its own system prompt, the delegation message, CLAUDE.md files, a git status snapshot and any skills listed in its `skills` field. A fork is the exception and inherits the parent conversation.

## Can you limit a subagent's tools and model?

Yes. The docs say subagents inherit the main conversation's tools unless restricted. `tools` is an allowlist and `disallowedTools` is a denylist. A researcher "that can't change anything" needs a read-only list, and Bash should stay off it because Bash can change files.

The `model` field accepts `sonnet`, `opus`, `haiku`, `fable`, a full model ID or `inherit`. That supports the video's advice to "put the researcher and the checker on a cheaper model." The docs name model routing as the main cost control.

## How do you stop a checker from passing bad work?

Give it concrete criteria. The video says a checker told only to "make sure it is good" fails, and that "the checklist is the whole job." The January 2026 article names "marking outputs as passing without thorough testing" as the most significant failure mode for verification subagents. Its fixes are concrete criteria, thorough checks and explicit instructions to run the full set.

The video credits the name "the early victory problem" to Anthropic, but that phrase does not appear in the article.

## Can Claude Code be stopped from sending without asking?

The video says a line in a job file saying "never send" is not enough, and that viewers should set a rule to "ask me before sending anything on every app."

Claude Code's auto mode docs support the warning. Explicit ask rules are evaluated before the classifier and "always force a permission prompt, even in auto mode." The docs also say a boundary stated in conversation, such as "don't push until I review," can be lost when context is compacted, and they recommend an ask or deny rule instead.

Ask rules are patterns on specific commands, such as `Bash(git push *)` and `Bash(gh pr create *)`. No documentation shows a plain-English request turning into a rule that covers every app. You can print the rules in effect with `claude auto-mode config`.

## What does it cost to run?

The video says "every employee runs on the same plan usage as you." The subagents docs confirm that subagent requests "count toward the same usage limits" as the main conversation. The docs add that each subagent's results return to the main conversation and take up its context.

The claim that three agents once a week "is fine on a normal plan" while ten running all day is not comes with no numbers. The video's Monday 7 AM schedule and its per-subagent usage display have no source in Anthropic's docs.

## Bottom line

Anthropic's own writing supports the core advice: fewer agents split by what they read, a checker with concrete criteria, and model choice as the main cost lever. Anthropic has used reference-based handoffs but does not recommend this exact folder pipeline. A durable "ask before sending" guarantee needs ask rules on specific commands, not a sentence in a prompt.

## Sources

- [Building multi-agent systems: When and how to use them, Anthropic, January 23, 2026](https://claude.com/resources/articles/building-multi-agent-systems-when-and-how-to-use-them): the 3-10x token figure, handoff loss, coordination overhead and verifier failure.
- [How we built our multi-agent research system, Anthropic engineering, June 13, 2025](https://www.anthropic.com/engineering/multi-agent-research-system): the 4x and 15x token multiples and lightweight-reference handoffs.
- [Create custom subagents, Claude Code docs](https://code.claude.com/docs/en/sub-agents): context isolation, tool allowlists, the model field and shared usage limits.
- [Configure auto mode, Claude Code docs](https://code.claude.com/docs/en/auto-mode-config): ask rules in auto mode, pattern limits and conversation-stated boundaries.


## Video description and verification notes

**The file is a 249.8 s vertical video (720x1280, 9:16) in an MP4/MOV container, with H.264 High video at 30 fps (621,996 bit/s, 7,494 frames) and HE-AACv2 stereo audio at 44.1 kHz (64,044 bit/s), 21,622,165 bytes overall at 692,427 bit/s (ffprobe). metadata.json labels the format h264_720p_692424-1 and leaves fps null, so the 30 fps figure comes from ffprobe. It was posted by @pro.glitch (nickname "Professor Glitch", uploader id 7505864130625733662) at epoch 1794506677, which is 2026-11-12 18:04:37 UTC, and the metadata upload_date field says 20261112. The audio credit is "original sound - Professor Glitch". The description runs to roughly 1,900 characters, restates the whole argument as a numbered seven-step build, and ends with "Check my profile" plus four hashtags. Counts captured on 2026-11-13 at 13:02 UTC were 3,820 views, 197 likes, 2 comments, 51 reposts and 205 saves. I read five frames from the 2-second set: frame_001 (0 s), frame_010 (about 18 s), frame_040 (about 78 s), frame_080 (about 158 s) and frame_124 (about 246 s). I did not read the other frames, so my account of the visuals is partial. Frame 1 is a flat-style illustration titled "GIVE YOUR AI EMPLOYEE A TEAM / START TO FINISH", with four desks labelled RESEARCHER, WRITER, CHECKER and YOU, a folder labelled "handoff/", a phone card reading "4 reports ready to send" with APPROVE and STOP buttons, and a "review/" tray. Frame 10 shows five brains labelled PLANNER, EDITOR, WRITER, MANAGER and REVIEWER joined by dashed lines under the heading "5 BOTS NAMED BY JOB TITLE / ALL TALKING". Frame 40 shows "EMPLOYEE 3 / THE CHECKER" with a checklist reading "Numbers = facts page", "Right week", "Client's rules" and "No promises". Frame 80 shows a markdown editor window headed "ONE SKILL RUNS THEM IN ORDER" with the text "For each client, in order: 1. Use the researcher subagent. It saves a facts page to handoff/. 2. Use the writer subagent. It reads the facts page and saves a draft to handoff/. 3. Use the checker subagent. FAIL: fixes go back to the writer. Max 2 rounds. Still failing? Move it to review/ with a FLAG." Frame 124 is a closing card, "From one AI employee to a team that checks", advertising "INSIDE MY COMMUNITY / Step-by-step courses / Context, Skills, Memory" and "A FULL COURSE ON AI employees". A cartoon bearded presenter appears at the bottom of each frame I read, with word-by-word captions. In the frames I read, no terminal output, no real Claude Code session, no subagent file contents, no permission settings and no schedule screen appears. The editor in frame 80 is the only screen content. The transcript has 112 segments and roughly 600 words. It says that splitting agents by job title loses context and costs more tokens, so each agent should be split by what it reads. The proposed build is a researcher that writes one page per client, a writer that drafts from that page, and a checker with a written checklist and a two-round limit. Files in a shared folder carry the handoffs, a permission rule gates sending, and a Monday 7 AM schedule runs the skill. The last segment ends at 249.6 s against an audio duration of 249.81 s, so the transcript stays inside the audio and shows no sign of hallucinated trailing text. Whisper rendered "Claude" as "Cloud" throughout (for example "Cloud Code" at about 125 s), and I treat every such instance as Claude.**

## "Anthropic tested that setup": supported, with one number the video blends

At 22.08 s the video says "Anthropic tested that kind of setup." At 24.24 s it continues "It lost context at every handoff and spent more tokens coordinating than working," and at 26.88 s it says "Teams of agents can use three to 10 times the tokens for the same job." Anthropic's article ["Building multi-agent systems: When and how to use them"](https://claude.com/resources/articles/building-multi-agent-systems-when-and-how-to-use-them) is dated January 23, 2026, and supports all three statements. It says multi-agent implementations "typically use 3-10x more tokens than single-agent approaches for equivalent tasks." It attributes the extra cost to duplicated context, messages between agents and summarizing results at handoffs. It also describes teams that "suffered from lost context at each handoff," and an experiment with role-based agents in which the subagents spent more tokens on coordination than on the work.

The video turns this into a rule about job-title bots, and the rule is a fair reading. The frame 10 diagram of five bots named Planner, Editor, Writer, Manager and Reviewer matches the pattern the article warns about. I did not find "five" bots stated in the article text I retrieved, so the specific count of five is the video's illustration, not a reported experimental setup. One caution on figures: Anthropic's earlier engineering post on its research system, [How we built our multi-agent research system](https://www.anthropic.com/engineering/multi-agent-research-system), published June 13, 2025, gives different multipliers. It says agents use about 4 times the tokens of chat and multi-agent systems about 15 times. These are measured against chat, not against a single agent, so the "3 to 10 times" figure belongs to the January 2026 comparison with single-agent setups and should not be mixed with the 15 times figure. The video cites only the 3 to 10 times figure, which matches its source.

## "Anthropic recommends exactly that" (files as handoffs): partly supported

At 103.12 s the video says "Anthropic recommends exactly that, so nothing gets lost in a game of telephone," where "that" is passing work between agents as files in a shared folder. The January 2026 multi-agent article does use the telephone-game image for information degrading across handoffs. The retrieval I ran on that article found no discussion of shared files or a filesystem as the handoff mechanism, so that article does not recommend what the video says it does.

The nearest primary source is the June 2025 research-system post, which describes subagents that store their work externally and pass "lightweight references" back to the coordinator, with the stated aim of cutting information loss and token overhead. That supports a file or pointer handoff as a design Anthropic uses, which is weaker than "Anthropic recommends exactly" a researcher-writer-checker folder pipeline. I read both pages through a summarizing fetch tool, not as raw text, so the quoted fragments are short and I did not verify surrounding wording. The folder names in the video (handoff/ and review/ in frames 1 and 80) belong to the presenter's example. No Anthropic page I read uses them.

## "Starts blank", tools and model: verified against the Claude Code subagent docs

The video says at 127.04 s that "a sub agent starts blank. It doesn't see your chat," so everything must go "in its job file or on the page it's handed." It also says each subagent has its own job, its own list of tools and its own model (120.48 to 123.12 s). The [Claude Code subagents documentation](https://code.claude.com/docs/en/sub-agents) confirms the first claim. Subagents "don't see the parent conversation by default," and each starts with a fresh, isolated context window. A non-fork subagent starts with its own system prompt, the delegation message, the CLAUDE.md files, a git status snapshot and any skills listed in its `skills` field. The page also notes one exception the video omits: a fork inherits the parent conversation. CLAUDE.md content does reach a regular subagent, so "blank" is slightly too strong, though the chat history and files the parent has read do not carry over.

On tools, the docs say subagents inherit the main conversation's tools unless restricted, and that `tools` is an allowlist while `disallowedTools` is a denylist. A researcher "that can't change anything" is therefore achievable by listing read-only tools, and the docs show an example named safe-researcher with `tools: Read, Grep, Glob, Bash`. Bash is not read-only in general, so a strictly read-only researcher needs a narrower list than that example. On the model, the `model` field accepts `sonnet`, `opus`, `haiku`, `fable`, a full model ID or `inherit`. That supports the advice at 221.52 s to "put the researcher and the checker on a cheaper model." The docs name the same lever: routing work to cheaper models is the main cost control, with `model: haiku` for exploration as their example. I do not state which specific models are cheapest or newest here, since that changes and is not the video's claim.

## The checker and the "early victory problem": failure mode confirmed, the name is unconfirmed

At 141.36 s the video says "Anthropic calls it the early victory problem," about a checker told only to make sure it is good. The January 2026 article does describe the failure. It names "marking outputs as passing without thorough testing" as the most significant failure mode for verification subagents, and describes a verifier that runs one or two tests, sees them pass and declares success. Its mitigations are concrete criteria, comprehensive checks and explicit instructions to run the full set. That backs the video's advice that "the checklist is the whole job" (146.32 s), and the frame 40 checklist ("Numbers = facts page", "Right week", "Client's rules", "No promises") is an example of concrete criteria.

The phrase "early victory" did not appear in the retrieved text of that article. A web search tied the phrase to Anthropic's separate long-running-agent harness posts, but every hit was a secondary write-up, and I could not read Anthropic's own harness posts, so I cannot confirm the exact name or its origin. The cap of "two rounds back to the writer" (149.12 s) is the presenter's design choice, visible as "Max 2 rounds" in frame 80. Nothing I read shows Anthropic prescribing two rounds.

## "Ask me before sending anything on every app" and auto mode: the rule type exists, the wording is untested

At 164.48 s the video says Claude Code "now starts in auto mode," so "a line in the job file that says never send isn't enough." It tells viewers to say "ask me before sending anything on every app," which "becomes a rule Claude Code enforces itself, whatever the employees decide" (176.8 to 178.8 s). The [auto mode configuration docs](https://code.claude.com/docs/en/auto-mode-config) support the core idea. They say explicit ask rules are evaluated before the classifier and "always force a permission prompt, even in auto mode," and that the classifier cannot auto-approve a matching action. The same page distinguishes this from a boundary stated in conversation. A one-off instruction such as "don't push until I review" can be lost if context compaction removes the message, and the page recommends an ask or deny rule for a durable guarantee. The video's warning that a line in a prompt is not a lock therefore matches the docs.

The docs show ask rules as content-scoped patterns on specific commands, for example `Bash(git push *)` and `Bash(gh pr create *)`. They also warn that a push written another way, such as `git -C <dir> push`, does not match, and they point to a PreToolUse hook for full-command inspection. I found no documentation that a plain-English request to "ask before sending on every app" is turned into a rule covering every email or messaging tool, and the video shows no settings screen. This part of the claim is unverified, and a pattern rule only covers the commands and tools it names. Whether sessions start in auto mode by default also went unchecked: the docs I read say auto mode is available to all users and point to separate pages for how to start in it, so "now starts in auto mode" is not confirmed by the pages I read. The user-facing check the docs give is `claude auto-mode config`, which prints the effective rules.

## Cost and schedule claims: partly sourced

At 216.0 s the video says "every employee runs on the same plan usage as you." The subagents docs state that subagent requests "count toward the same usage limits" as the main conversation, which verifies it. The video adds at 218.72 s that "Claude Code shows you what each one uses." I did not find a per-subagent usage display in the pages I read, so that sentence is unverified. The claim that "three employees once a week is fine on a normal plan" while "10 running all day isn't" (224.56 to 226.48 s) is the presenter's judgment, with no usage numbers shown or sourced. The docs do add one related cost point the video omits: a subagent's detailed results return to the main conversation, so many subagents can consume significant context.

At 184.72 s the video says that on Monday at seven, "with your computer awake, the schedule runs the skill." My search for official scheduled-task documentation returned only a third-party guide to `/loop` and `/schedule`, which I could not check against Anthropic's own pages, so the scheduling mechanism and the awake-computer condition remain unverified. The ending pitch sends viewers to a community with "step-by-step courses" through a link "in my profile." That link sits behind TikTok, which I did not fetch, and I could not follow it, so I cannot say what the courses cost or contain.

## Key Takeaways

- **Verified:** The 3 to 10 times token figure, lost context at each handoff, and more tokens spent on coordination than work all come from Anthropic's January 23, 2026 multi-agent article, as a comparison with single-agent setups.
- **Verified:** A Claude Code subagent has its own context window and does not see the parent conversation, and subagent usage counts toward the same limits as the main session. The `tools` allowlist and `model` field exist as the video describes.
- **Partial correction:** At 103.12 s the video says "Anthropic recommends exactly that" about shared-file handoffs. The January 2026 article I read does not discuss files. The June 2025 research-system post describes subagents returning lightweight references, which is a looser match.
- **Partial correction:** "A sub agent starts blank" is slightly too strong. The docs list CLAUDE.md files, a git status snapshot and listed skills in a subagent's initial context, and forks inherit the parent conversation.
- **Clarification:** An ask rule is a content-scoped pattern, such as `Bash(git push *)`, that prompts even in auto mode. Anthropic's example does not show a blanket "every app" rule, so the video's wording is untested.
- **Unverified:** The exact name "early victory problem," the "Claude Code shows what each one uses" display, the Monday 7 AM scheduling with an awake computer, and the "normal plan" capacity claims. I found no first-party source for any of them.
- **Context:** The frames I read show illustrations and one editor screenshot, not a live run, so the pipeline's results (reports produced, errors caught) are described but never demonstrated.

## Resources

- [Building multi-agent systems: When and how to use them, Anthropic (claude.com), January 23, 2026](https://claude.com/resources/articles/building-multi-agent-systems-when-and-how-to-use-them) establishes the 3-10x token figure, lost context at handoffs, coordination overhead and the verifier failure mode I cite.
- [How we built our multi-agent research system, Anthropic engineering, June 13, 2025](https://www.anthropic.com/engineering/multi-agent-research-system) establishes the 4x and 15x token multiples against chat and the lightweight-reference handoff pattern I cite.
- [Create custom subagents, Claude Code docs](https://code.claude.com/docs/en/sub-agents) establishes subagent context isolation, tool allowlists, the model field and shared usage limits.
- [Configure auto mode, Claude Code docs](https://code.claude.com/docs/en/auto-mode-config) establishes that ask rules prompt even in auto mode, the pattern-matching limits, and the contrast with conversation-stated boundaries.
