Our agent repository has tracked
.claude/settings.local.jsonin git since its first commit, the file Claude Code writes to when you answer a permission prompt with "Yes, and don't ask again". In the 10 commits that touched it between May 26 and October 29, it collected 15 allow rules and no deny or ask rules. None of the 15 held a token, a password or a path under a home directory. Five of them approve almost any command or file.
The report that sent us to our own history
On November 7 a post from Apiiro was submitted to Hacker News under a title saying that Claude Code's "Don't Ask Again" had exposed passwords in 1,122 public GitHub files. Our text fetchers could not load the post itself (one returned a page without the article text, and a second was refused), so we are relying on nothing but its title here, and none of the numbers below come from it.
The mechanism behind a title like that is documented by Claude Code itself. The settings page says that when Claude asks permission to run a Bash command and you choose "Yes, and don't ask again", "Claude Code saves that permission approval here as an" allow rule, where "here" is .claude/settings.local.json. The same page explains why that file normally never reaches a commit: the first time Claude Code writes it in a git repository that does not already ignore it, it adds **/.claude/settings.local.json to your global git excludes, "so the file stays out of your commits in every repository".
On the versions the page describes, then, something has to get past that default before the file reaches a commit: a repository that un-ignores it, a file created by hand before Claude Code ever wrote it, or a forced add. Ours un-ignores it on purpose, which made it a fair place to measure what actually accumulates in the file when it is committed for months.
Why we track a file that is meant to stay local
Our .gitignore carries an explicit negation, !.claude/settings.local.json, with a comment saying the file is tracked because its list of enabled plugins has to be shared. That has been true since the repository's first commit on May 26. The plugin list is the reason the file is in git; the permission rules came along with it, because Claude Code keeps both in the same file.
Tracking the file also changes how Claude Code treats it. The permissions page says that a local settings file is normally yours, so its allow rules apply without the workspace trust step, but when the file is tracked in git, Claude Code treats it as repository-supplied and "holds its rules until you trust the folder". The settings page says the same in fewer words: "If the file is tracked by git, the trust step applies to it too". In other words, a tracked local file is handled like the committed project file, and anyone who clones the repository and trusts the folder gets its rules.
The docs also point to the file built for shared settings: commit .claude/settings.json "so everyone who clones the repository gets the same permissions, hooks, and plugin settings". We kept the plugin list in the local file instead, and that choice is what put 15 permission rules into our history.
What 10 commits put into the file
We read every committed version of the file up to October 29 with git log -p and git show, and counted the permissions.allow, permissions.deny and permissions.ask arrays at each commit.
| Commit date | Allow rules after the commit | Rules added |
|---|---|---|
| 2026-05-26 | 8 | 8 (first commit of the repository) |
| 2026-05-27 | 9 | 1, in the older :* prefix form |
| 2026-08-18 | 9 | 0 |
| 2026-08-28 | 9 | 0 |
| 2026-09-14 | 10 | 1 |
| 2026-09-15 | 11 | 1 |
| 2026-09-22 | 11 | 0 |
| 2026-10-05 | 15 | 4 |
| 2026-10-25 | 15 | 0 |
| 2026-10-29 | 15 | 0 |
Five of the ten commits changed no permission rule at all; they touched the plugin list or another setting in the same file. No rule was removed in those 10 commits, and none of those versions held a deny or an ask rule. Over those five months the file only grew.
Two commit messages say where some of the rules came from. The May 27 commit says its one rule was added so that a command would stop being blocked again by auto mode's classifier, and it is the only rule in the older :* form. The October 5 commit says it took over a diff of four new allow rules that had sat uncommitted since September 29, and describes them as operations allowed on Claude Code's confirmation screen. For the first eight rules the history does not say whether a prompt or a person wrote them, so we do not count them either way.
The 15 rules by shape
We are not pasting the rules themselves. Even in a repository that is not public, a list of exact commands says more about the machine and the project than an article needs to. Sorted by shape, the 15 are:
- 6 exact commands with no wildcard. Three of them carry literal arguments exactly as they were typed: a temporary file path, two test directories, and a short text-processing program.
- 8 prefix rules that end in a space and
*, which is the form the permissions page says the dialog writes for a command prefix. - 1 prefix rule in the older
:*form, the one added on May 27.
None of the 15 contains a token, a password, an API key, an Authorization header or a path under a home directory. On the question the report's title raises, our history is clean.
On scope, it is not. Five rules approve far more than one command:
- one lets a file-printing utility read any file it is pointed at;
- one lets a copy command copy or overwrite any file;
- one lets the package manager's
execrun any executable it can find; - two let a scripting language's interpreter run whatever program it is handed, one reading the program from standard input and one taking it as a one-line argument.
The last two deserve the most attention. A prefix rule on an interpreter approves arbitrary code, because the program arrives as an argument or on standard input, after the part the rule checks. The remaining rules are narrower: four run named scripts from the project's package file with any arguments, one runs a read-only git log with any arguments, and the other five exact commands run exactly what they name.
What "Don't ask again" wrote on 2.1.322
To see the dialog's side of this on the version we run now, we made a fresh git repository in a temporary folder whose .gitignore already excluded .claude/settings.local.json, so Claude Code would not touch any global git config, and gave it a package.json with a test script that only echoes a line. We started Claude Code 2.1.322 interactively and asked it to run git status && npm test once. When the permission prompt appeared, our script chose the second option.
The option named the rule before saving it: npm test *. After the run the file held exactly 1 allow rule, Bash(npm test *), and no rule for git status, which had not needed approval. That matches the permissions page, which says that for a compound command "Claude Code saves a separate rule for each subcommand that requires approval", and that a rule saved from a prompt "covers only what its option named".
It also shows where the wildcard comes from. Approving npm test once saved a rule that approves npm test followed by anything. That is reasonable for a test runner, and it is the same shape as the broad rules in our own history: the rule covers a prefix, and whatever follows the prefix is approved too.
What we take from reading the history
The report's title is about values: passwords that end up inside saved rules. Our history points at the other risk, which is scope. It also shows how close the first risk sits. One of our exact rules with a literal argument, the short text-processing program, arrived in the October 5 batch that the commit message attributes to the confirmation screen, and the program is in the file exactly as it was typed. Had that argument been a password, it would be in our history now. The five broad rules show that a prefix rule on the wrong command quietly turns a single approval into a standing one.
If you track .claude/settings.local.json, or are about to:
- Read its diff in every pull request as you would read a change to a CI config, because it decides what the agent may do without asking.
- Look for prefix rules on interpreters, shells, package-manager
exec, and copy or move commands. Those are the rules that approve code or files you never saw. - Search the file's whole history, not only the current version, for anything that looks like a credential. A rule removed today is still in every earlier commit.
- If the reason for tracking it is shared plugins or other shared settings, check whether those settings can live in
.claude/settings.jsoninstead, and let the local file stay local as the default intends.
The default exists for a reason: Claude Code keeps this file out of your commits unless you, or your .gitignore, insist. We insisted for the plugin list, and five months later the file held 15 allow rules, five of them broad.
Do you commit .claude/settings.local.json, leave it ignored, or split shared settings into settings.json? If you have read its history, what did you find? Tell us in the comments below.

