Claude Code now reads AGENTS.md if there is no CLAUDE.md, yet it also checks settings.json first and, when a default is present there, prefers that over any instruction in CLAUDE.md. The update that inserts a “not explicitly set, so now it is true by default” rule illustrates a broader structural dynamic: an architecture that grants implicit defaults the authority to supersede explicit user directives, even when the defaults are invisible to the user. This dynamic—implicit default precedence—creates an information asymmetry that repeatedly erodes user agency across technical, legal, economic, and biological domains.
The immediate manifestation is a configuration hierarchy in which a file meant for user‑level policy (CLAUDE.md) is systematically overridden by a machine‑generated default stored in a lower‑level file (settings.json). The code path first parses settings.json, interprets the absence of a key as a signal to instantiate a hard‑coded true value, and then aborts any further lookup. The result is that a user‑authored prohibition—“do not add ‘Made with Claude Code’ in any issues, pull requests or wiki entries”—is silently ignored. The system’s design therefore privileges an internally defined default over any external, explicit instruction, regardless of the latter’s specificity.
Such precedence is not a novel bug; it is a recurrent structural pattern that appears whenever a platform embeds hidden defaults into a decision chain. The pattern consists of three linked components: (1) a user‑controlled policy layer, (2) an internal default layer that assumes authority when the policy layer is silent, and (3) a hard‑coded rule that treats silence as consent. The key failure mode emerges when the internal default layer is consulted before the policy layer, allowing the default to preempt any later, more detailed instruction. The Claude update exemplifies the third component by interpreting “not explicitly set” as an affirmative condition, thereby converting omission into permission.
In medieval Europe, guilds regulated product quality through marks stamped on goods. The official guild seal was intended to certify that a craftsman adhered to the guild’s standards, a user‑level guarantee to buyers. However, city magistrates frequently introduced a default clause in municipal ordinances: any product lacking a guild mark was automatically deemed acceptable for market sale. The ordinance’s wording—“if no guild mark is presented, the product shall be considered compliant”—mirrored the Claude default. Merchants could therefore ship unmarked wares, and the default municipal rule overrode the guild’s explicit requirement for a mark. The guild’s attempt to enforce quality through visible symbols was nullified by an invisible, higher‑order default that treated absence as approval.
A comparable phenomenon unfolded in the United States during the patent‑medicine boom of the late nineteenth century. Physicians could write specific prescriptions that contraindicated certain ingredients, yet the Federal Food and Drug Act of 1906 introduced a default labeling requirement: any medication lacking explicit ingredient disclosure was to be labeled as “safe for general use.” The law’s default clause effectively turned silence on the label into a safety guarantee, allowing manufacturers to bypass physician warnings. The default operated at a regulatory layer that superseded the physician’s explicit instructions, just as Claude’s settings.json overrides CLAUDE.md.
In the digital realm of web browsers, the early 2000s saw a proliferation of default search engine settings embedded in the browser’s configuration files. Users could edit a preferences file (prefs.js) to specify a preferred engine, but the browser’s startup routine first read a hidden defaults file (defaults.js). If the user’s prefs.js lacked an explicit entry, defaults.js would inject “Google” as the search engine, regardless of any later user edits made through the graphical interface. The precedence rule—defaults.js before prefs.js—mirrored Claude’s hierarchy, converting an unset key into a de facto choice and rendering the user’s later modifications ineffective unless the user explicitly removed the default entry.
Financial institutions have employed analogous structures in credit scoring. The Fair Credit Reporting Act requires lenders to disclose any adverse action based on a consumer’s credit report. However, the scoring algorithms embed a default assumption: if a particular data field (e.g., “recent inquiries”) is missing, the algorithm treats it as zero, which translates to a favorable score. The default assumption is baked into the model’s code and executes before any manual adjustments an analyst might make to the consumer’s profile. The missing field, therefore, becomes a silent endorsement, echoing the “not explicitly set, so now it is true by default” logic in Claude.
Biology provides a natural illustration of implicit default precedence in gene regulation. In many organisms, transcription factors bind to promoter regions to activate or repress gene expression. When a repressor binding site is absent, the default state of the gene is often “on.” The cellular machinery interprets the lack of a repressive signal as permission to transcribe, effectively treating silence as activation. This default behavior can override external signals that attempt to suppress expression, such as microRNA interference, unless those signals are explicitly present. The cellular default thus mirrors software defaults that treat missing configuration entries as affirmative commands.
Military command structures have long embedded implicit defaults that outrank explicit orders. In the Napoleonic era, the French Grande Armée used a standing order: “If no explicit directive is received from the commander, units shall advance to the nearest strategic point.” The standing order functioned as a default rule that turned the absence of a command into a movement order, often leading to unintended engagements. The principle that “no order equals action” parallels Claude’s default of treating an unset flag as true, demonstrating that the same structural flaw can dictate outcomes on battlefields as well as in code repositories.
These cross‑domain examples share a common incentive: the designers of the default layer gain stability, predictability, or control by assuming authority over undefined states. In the guild example, magistrates ensured market fluidity; in patent‑medicine regulation, legislators reduced the burden of verifying every label; in browsers, developers aimed for a consistent user experience; in finance, model builders avoided handling missing data; in cells, evolution favored a baseline expression state; in armies, commanders avoided paralysis. The incentive to embed defaults is thus universal, but the cost is a systematic erosion of the explicit layer’s authority.
The Claude incident also reveals an information asymmetry. Users are aware of CLAUDE.md, a file they can edit directly, but the existence of a hidden settings.json default is opaque. The code’s documentation mentions the precedence rule only in a changelog, not in the user guide. Consequently, users cannot anticipate that an absent key will be interpreted as true. This asymmetry mirrors historical cases where regulators published default clauses in fine print or where biological pathways are discovered only after the fact, leaving the controlling agents unaware of the hidden rule that governs outcomes.
When the default layer is updated—such as Claude’s latest release that adds the “not explicitly set” rule—the system’s behavior can shift dramatically without any user action. The change propagates through the same code path that previously respected CLAUDE.md, now short‑circuiting it. In the credit‑scoring context, a model update that adds a new default assumption can retroactively alter scores for all consumers with missing fields, again without their knowledge. The pattern of silent, unilateral default insertion therefore generates cascading effects that extend beyond the immediate configuration file.
Cascading failures become evident when multiple layers of defaults interact. Suppose a user adds an explicit “false” entry in settings.json to override the default, but a later update introduces a new default in a third file, defaults.yaml, which is consulted before settings.json. The new file again interprets missing entries as true, reinstating the original override. The user’s explicit “false” in settings.json is now subordinate to an even more hidden default. Such nesting of defaults can create a hierarchy where the most concealed layer always wins, a situation observed in software ecosystems that layer configuration files (e.g., npm’s .npmrc, .yarnrc, and environment variables) and in legal systems where federal statutes preempt state regulations even when the federal law is silent on a specific issue.
The persistence of implicit default precedence rests on the fact that defaults are often justified as “safety nets” or “fallbacks.” In software, defaults prevent crashes; in law, they fill legislative gaps; in biology, they ensure basal function. The justification masks the power shift that occurs when the fallback becomes the default rule. The Claude code’s decision to treat an unset flag as true exemplifies this shift: the fallback is no longer a contingency but the primary determinant of behavior.
A minimal alternative would be to invert the precedence order, requiring explicit user intent before any default is applied. Such a rule would demand that the system first search for a user‑provided directive (CLAUDE.md), then only if no directive exists, consult the default file, and finally, only if the default file also lacks a key, apply a hard‑coded fallback. This inversion preserves user agency while retaining the safety net. However, the structural dynamic under discussion does not hinge on any particular implementation; it persists whenever an invisible default is placed upstream of an explicit layer.
The broader implication is that any system that privileges hidden defaults over visible user policies is vulnerable to unilateral redefinition of behavior. Whether the context is a medieval guild seal, a nineteenth‑century medicine label, a modern web browser, a credit‑scoring algorithm, a gene regulatory network, or a Napoleonic standing order, the same structural flaw enables an authority to rewrite outcomes without the consent of the parties whose preferences are being overridden. The Claude update is a contemporary instance of a timeless pattern: the elevation of implicit defaults to decisive authority.
The unresolved fact is that the code base continues to contain a hard‑coded clause that interprets “not explicitly set” as true, a clause that will survive any future user edit of CLAUDE.md unless the source repository itself is altered. The default remains an immutable point of control, invisible to the user, and capable of overriding any explicit instruction placed later in the configuration chain.