Claude Code output styles are not inherited by subagents — the official spec, and checking it in practice
Introduction
I want every exchange with an AI coding assistant to follow a form of my own: lead with the point, structure things as tables, do not repeat the same thing in different words. That wish was met by building a separate setting that instructs only the format and density of responses (an output style).
When I built it, I vaguely thought “this has changed how the assistant responds, across the board”. In fact, that instruction had never reached the subordinate AIs (subagents) I hand work to. This is the record of confirming the official specification, and measuring whether my own configuration had fallen into a dangerous default state.
Premise — treat context as a finite resource
Why this matters needs to be grounded first in a design principle Anthropic itself publishes.
Studies on needle-in-a-haystack style benchmarking have uncovered the concept of context rot: as the number of tokens in the context window increases, the model’s ability to accurately recall information from that context decreases.
LLMs have an “attention budget” … Every new token introduced depletes this budget by some amount.
The more information you pack into the conversation, the lower the probability that the model recalls it accurately. So applying a rule you want in force every turn — like response-style instructions — carelessly to everything puts that rule itself on the side that consumes this finite resource. The same document also says:
good context engineering means finding the smallest possible set of high-signal tokens that maximize the likelihood of some desired outcome.
Note that minimal does not necessarily mean short; you still need to give the agent sufficient information up front to ensure it adheres to the desired behavior.
“Minimal” does not mean “short”. Do not cut the instructions you need, but do not duplicate needlessly — the design judgement of where a response style should apply and where it should not is a concrete instance of that principle.
The default I had overlooked
First I confirmed the mechanism of response styles itself against the official specification.
Custom output styles leave out Claude Code’s built-in software engineering instructions, such as how to scope changes, write comments, and verify work, unless
keep-coding-instructionsis set totrue.
The list of defaults ran as follows.
| Setting | Default |
|---|---|
keep-coding-instructions | false |
The moment you create a custom response style, the standard discipline for implementation work (scoping changes, writing comments, verifying work) comes off wholesale by default. What you meant as a change to response format was, unless you specified otherwise, designed to remove the instructions that underwrite implementation quality along with it.
Measuring my own configuration
Rather than settling for an assumption, I checked the contents of my own settings file.
---
name: <my own response style name>
description: my own response style, instructing lead-with-the-point, table structuring, avoiding redundancy, presenting both sides
keep-coding-instructions: true
---
keep-coding-instructions was explicitly true (measured 2026-08-14). Not applicable — the standard implementation discipline is retained, and only the format and density of responses are overwritten by my own instructions. Had this been left at the default, responses would have looked tidy while the instructions underwriting implementation quality had quietly gone missing.
It never reached subagents in the first place
There was one more thing to confirm. Does this response style apply to the subordinate AIs I hand work to? The official spec says:
Output styles apply to the main conversation only: a subagent runs its own system prompt, so styles don’t change how subagents respond. A fork is the exception, because it inherits the parent’s full system prompt.
Because a subagent runs on a system prompt of its own, response styles do not reach it. The one exception is the special execution mode called a “fork”, which carries the parent conversation across as it stands; ordinary delegation (handing work to a named subagent) does not fall under that exception.
My assumption that “my response style must be applying to subagents too” was corrected here. What a subordinate AI receives is only what is written in its definition file plus minimal environment information — not the response style, and not even the system prompt of the ordinary conversation as a whole.
Subagents receive only this system prompt plus basic environment details like the working directory, not the full Claude Code system prompt.
Diagram — where it reaches and where it does not
set a response style of your own
│
├─▶ the main conversation
│ └─ appended to the end of the system prompt (official)
│ └─ a reminder to "keep to this style" is raised every turn (official)
│
├─▶ named subagents (the subordinate AIs work is handed to)
│ └─ ⛔ does not reach them (official) ── because they run on a system prompt of their own
│ │
│ └─▶ the only exception: a fork (an execution mode carrying the parent conversation across)
│ └─ only here is the parent's response style inherited too
│
└─▶ check the default in force the moment a custom style is created
└─ the default of keep-coding-instructions is false (official)
└─ do nothing and the implementation discipline comes off with it
└─(return edge)→ measure my own settings file
└─ confirmed already set to true (2026-08-14)
The vertical flow is “from creating a response style to confirming where it applies”, the horizontal branches are the three destinations “main conversation, subagents, and the exception”, and the nesting at the bottom is the loop of “suspect the dangerous default, and confirm by measuring your own configuration”.
What became clear, and what has not
Two things became clear from this check.
| What was checked | Result |
|---|---|
| Whether the custom response style had swept the implementation discipline off with it | Not applicable (confirmed by measurement: keep-coding-instructions: true) |
| Whether the response style applies to the subordinate AIs work is handed to | It does not (stated in the official spec except for forks; this was an assumption) |
On the other hand, I have not yet measured how much volume the “reminder to comply” that the response style itself raises every turn occupies in the conversation.
All output styles trigger reminders for Claude to adhere to the output style instructions during the conversation.
This is not confined to response styles; it competes for the same finite resource as every other mechanism injected into the conversation each turn. I could confirm “does it reach”, but not yet “how heavy is it once it reaches” — that goes in only once measured.
How far the instructions you write actually reach is invisible from where you write them. Without confirming the reach against the specification, you read the output of a party the instruction never reached as output that ignores your instruction — that misreading was what I most wanted to avoid here.