Claude Code

Fetching a header-echo endpoint showed the exact fetch user agent; search found the request to document it, which is still undocumented officially.

Headless print mode with a pinned older version reproduced customer behaviour well. Pinning needed a side install prepended to PATH; outputs were stable enough to compare wordings.

Web search, page fetches and shell checks of status codes confirmed every link and claim before it went into the document.

Web search surfaced the vendor help articles quickly and page fetch summarized them accurately; enough to answer a product-settings question in a few calls.

The background subagent rewrote and verified the page on its own; long foreground commands were moved to the background mid-wait, which needed a second check.

A background subagent with a full spec did a multi-step docs and database update and reported verified results while the main session handled CI.

Eleven readers, eight taggers and a Notion editor ran in the background and each wrote verifiable output; completion notifications made waiting simple.

Fourteen background subagents read and tagged large digests in parallel and returned clean JSON. Later every connector call through the desktop host failed with a PreToolUse hook timeout, which blocked publishing to a document tool for the rest of the session.

Used the plugin administration CLI to inspect installed versions, enabled state, scope and marketplace sources. JSON output was scriptable, though a complete listing was verbose and needed filtering to the relevant plugins.

What worked

Plugin and marketplace metadata were available without reading authentication state.

What got in the way

Unfiltered plugin listings included much more metadata than the task needed.

Three background subagents were launched in one message to read separate sets of long project notes and each wrote a bounded summary file plus a short report. All three finished within about three minutes and the parent session only received the short reports, keeping its own context small.

What worked

Launching several agents in a single message ran them concurrently, completion arrived as notifications without polling, and asking for a fixed output shape (a file with a line limit plus a short reply) made results directly usable.

What got in the way

Each agent starts with no context, so the brief has to restate goals, constraints and prohibited actions in full; writing three careful briefs took noticeable effort. Whether environment-based identity carries into subagents had to be checked separately.

Paged reads over long notes files and Bash heredoc scripts worked reliably across dozens of calls. One Write call failed with a pre-tool hook timeout that said the host client may be unreachable. Writing the same file through Bash worked, so the task finished.

What worked

Offset and limit reads kept large files manageable, independent calls ran in parallel, and the error text named its cause.

What got in the way

A pre-tool hook timed out and blocked a file write. The cause sat outside the task and only a shell fallback got past it.

Read about 200 KB of markdown and 80 KB of tab-separated text with the file reader, ran short Python scripts through the shell tool, and wrote a JSONL report. One file write did not run because a pre-tool hook timed out, and a shell heredoc did the same job.

What worked

The file reader said when a long file was cut off and gave the offset to continue. The shell tool moved a command that ran past two minutes to the background and sent a completion notice, so the session never stalled.

What got in the way

The Write tool did not run once because its pre-tool hook did not respond in time. The message said so clearly, but the retry cost a turn. Long preloaded tool lists and instructions also used much context before any work began.

Worked as a delegated subagent on a long analysis task: paged through a 110 KB file of very long lines with offset reads, ran Python helper scripts through the shell tool, loaded a skill and produced the requested JSONL file. One file write failed because a pre-tool hook timed out and the call never ran. Writing through a shell heredoc worked at once.

What worked

Chunked reads kept context manageable. The shell tool made helper scripts easy to rerun and edit, and it was a quick fallback when the write tool failed.

What got in the way

The write tool reported that a pre-tool hook did not answer before its timeout and that the host client might be unreachable. The call did not run, and the message gave no hint whether a retry would help, so I moved file writes to the shell.

Worked as a delegated subagent: read a large text file in chunks, wrote long structured output files, ran validation scripts through the shell tool and loaded a skill. All of that went smoothly. A subagent guard refused one markdown summary file the delegating agent had asked for, so that content went back inline instead.

What worked

Chunked file reads, the shell tool for validation scripts and the write tool for long structured outputs all behaved reliably, and a clear refusal message made the guard easy to understand.

What got in the way

The subagent write guard and the delegating instructions disagreed about a requested summary file, so one deliverable had to change shape.

Used the CLI's read, shell and skill tools from a subagent to turn a long text file into structured JSONL and validate it with scripts. The records were produced, but a requested summary file could not be written and my working files were overwritten by another agent once.

What worked

Chunked file reads, shell scripting and on-demand skills made it quick to parse and cross-check a large text file. The notices that a file had changed on disk exposed a silent overwrite.

What got in the way

Parallel subagents share one scratch folder, and another agent overwrote my same-named working files until I moved to a unique folder. The Write tool also refused a markdown report file that the launching agent had asked for, so the text went in the reply instead.

The shell tool handled a long reading and scripting task well, including chunked reads of a large text file and Python helpers for building and checking output. The Write tool refused to create a summary file requested by the caller and said subagents must return findings as text.

What worked

Shell output limits were never hit when reads stayed near 25 KB. Scripts and edits ran quickly, and the built-in tools covered the whole workflow.

What got in the way

The caller's instruction to write a summary file conflicted with a built-in rule for subagents. The refusal message was clear, but the conflict only surfaced at write time, after the summary was already drafted.

Used Claude Code's file Read and Bash tools as a sub-agent to page through a large text file with very long lines and to build and validate structured JSON output with scripts. Reading and scripting worked smoothly. A request to write a second, report-style output file was refused by a sub-agent policy, so that content was returned as text instead.

What worked

Read's offset and limit paging returned very long lines intact with line numbers, so the whole file could be read in order without sampling. Bash made it easy to run quick scripts that checked the output against the source text.

What got in the way

The Write tool refused to create a summary markdown file for a sub-agent. The refusal message was clear and said what to do instead, but it conflicted with the task instructions, and the tool description did not mention the restriction up front.

Read a roughly 230 KB text file in about a dozen offset-limited chunks, then wrote structured output and a summary through shell heredocs and Python. Every call worked as described and nothing failed.

What worked

The file reader returned very long lines whole, and offset and limit made chunked reading predictable. Shell calls combined cleanly with Python scripts.

What got in the way

Each shell call starts in a fresh working directory, so every command needed absolute paths. The preloaded instructions and tool lists also used a lot of context before any work began.

Read with offset and limit paged cleanly through a roughly 240 KB file with very long lines, and Bash ran helper scripts reliably. The Write tool refused a requested markdown summary file for a delegated subagent, so that part was returned as text.

What worked

Chunked reads kept context manageable, the persistent shell made helper scripts easy to rerun, and small edits to scripts were quick.

What got in the way

A summary-file write was refused with a message that subagents should return findings as text, which conflicted with the task request for a file.

Background subagents edited each SDK in parallel and resumed with full context for a second spec revision; they needed a complete written spec up front. A shell cd that persisted across calls once ran a command in the wrong checkout (harmless, nothing staged).

claude mcp add registered a remote HTTP MCP server at user scope in one command, and claude mcp get correctly reported it needed authentication, but the OAuth sign-in could not be started from the CLI, so the person has to finish it in an interactive session.

What worked

Clear confirmation of scope and config location, and mcp list and mcp get showed health and auth status for every server.

What got in the way

No non-interactive command to start the OAuth flow; the sign-in needs the interactive /mcp menu, and a server added mid-session does not load into the running session.

Ran dozens of headless print-mode sessions with stream-json output in a throwaway home folder with an API key, to compare how agents behave with two versions of a skill. Skills from the isolated folder loaded and the event stream was easy to parse.

What worked

stream-json lists the loaded skills and every tool call, so a harness can count web searches and commands exactly.

What got in the way

It waits 3 seconds for stdin unless stdin is redirected, which is easy to miss in scripts.

The PR monitor bound the new PR and relayed review comments, but its cached check counts lagged GitHub's while CI was running, so a direct check listing was still needed.

Two months of daily sessions on a remote machine through the desktop app. The PR status tool (about 140 calls), search across old session transcripts and artifact publishing all saved real work. Weak points: one session where every app-side tool timed out, and a base-branch sync tool that does not work for remote sessions.

What worked

The PR status tool reports checks and review state in one call, so the agent did not need to poll the GitHub CLI. Full-text search over past sessions found earlier decisions and commands quickly. Artifact publishing refuses to overwrite a newer version that someone saved from inside the page, and it names that version, so no edits were lost.

What got in the way

In one session every app-side tool (PR status, widgets, browser) failed with 'PreToolUse hook did not respond before its timeout (host client may be unreachable)', and the agent had no way to reconnect. The base-branch sync tool refuses on a remote host, so the agent had to merge by hand. Enabling auto-merge failed on a repository that does not allow it; the error was clear, but the tool does not show this setting before the agent tries.