Build1 publisher3 min readPublished
A dev.to write-up follows the bytes past the prompt box into the envelope a client assembles around it, then pairs one git command with a local scanner that reads the ignored-file list as an attachment manifest.
The Engineer · Build desk

Follow any of these and your For You feed starts watching them — no settings page required.
Compiled by The EngineerSomething wrong?How this is made
The scanner is two independent tests per path, and each one can return nothing. First the filename, lowercased, against seven substrings: `.env`, `id_rsa`, `id_ed25519`, `credentials`, `service-account`, `.pem`, `.p12` [13]. Then the contents, read as text with decode errors ignored and truncated to the first 200,000 characters [14], against five regexes: a generic api_key/secret/token/password assignment, `AKIA` plus sixteen uppercase alphanumerics, a PRIVATE KEY header, a postgres URL, a mongodb URL [12]. Twelve heuristics in total [1]. A path is printed only when one of them fires [17].
On the article's own example the coverage is generous. `secrets/dev.pem` trips the `.pem` hint, `.env` trips the `.env` hint, and a `DATABASE_URL` in `postgres://` form trips the db_url pattern as well [10][2]. Change the file and the coverage thins. An ignored debug log with the connection string sitting past byte 300,000 is outside the read window [3]. A Stripe key isn't among the five patterns, and neither is an Azure connection string or a base64-encoded service account blob, so none of them print [4]. What the clean run actually reports is no match against twelve heuristics, which is a narrower statement than safe to attach [5].
The enumeration has a boundary too. `git ls-files -o -i --exclude-standard` returns the untracked, ignored paths inside the repository [11], while the agent, in the post's phrasing, walks the working tree with a flashlight and reads whichever path a tool policy still allows [9]. Credentials that live in a home directory were never in the working tree, so git has no opinion about them and never offered one [6]. The listing is a subset of the read surface. The part it omits is exactly the part git cannot tell you about.
The dev.to post argues from mechanism rather than from incident. It names no client, publishes no measurement of how often an agent opens a `.env`, and presents the script as a local proposal that contacts no model and uploads nothing [15][7]. For the threat model to transfer to your machine, the client has to pack nearby files without being asked [4], its tool policy has to permit the paths your gitignore covers [2], and your ignored tree has to hold live credentials rather than fixtures. The first is described as default agent behaviour [4]. The other two are checkable in an afternoon.
The command is the part worth adopting first. It converts a habit (these files are private because I never committed them) into a list you can read as an attachment manifest before a session starts [11][3]. Whether you keep the author's regexes matters less than whether anything at all reads that list, because the post's own framing puts the leak in the envelope assembled around the chat box rather than in the text you typed [18].
Ranked by verification strength, evidence, and original report placement.
Gitignore will not stop a coding agent from reading files you refused to commit; the privacy boundary inherited from version control ends at the git index, not at the model.
If an assistant can open a path on disk, that path can leave the machine inside a tool result.
Gitignore is a shipping label for human collaborators, not a vault door: it only tells git which files stay off the next commit, and does not block tools that share your username.
Open buffers and recently touched files often include .env, credentials.json and editor swap files that git already ignores.
Command output becomes a second copy of the same secrets when the agent runs env, docker compose config, or cat on a path you would never publish; tool results also freeze stack traces that reprint connection strings from a failed boot.
The agent walks the working tree with a flashlight and reads whichever path a tool policy still allows.
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Inspectable script, asserted premise
Every falsifiable part of this post is printed inside it: the git invocation, the five regexes, the seven filename hints, the 200,000-character read cap, the exact string main() prints when nothing matches. Those we could re-derive line by line. The premise that gives the piece its urgency gets no such treatment: dev.to doesn't name an agent client or show a session, and it offers no count of assistants opening ignored credential files. No other publisher covers the same ground.
Nothing running yet
The scanner exists as text in a blog post: no repository, no install path, and no account of a run against anyone's real ignored tree, the author's included. Nor is there a named client whose attachment behaviour someone could watch. That is an absence of measurement rather than evidence of low uptake, so we score nothing.
Mild overreach, largely contained
The author pre-empts most of what would inflate this, saying plainly that short tokens, screenshots in tmp and base64 blobs sail through the patterns and that the output certifies nothing. What tips the balance slightly over is urgency without frequency: 'treat every ignored file as model-visible' is a defensible default, yet the reader is left to assume it describes the client on their own machine, and the twelve heuristics are weakest against exactly the credential formats the post never enumerates.
No product behind it
Just an individual author on dev.to: there is no vendor behind this, and no tool to buy or affiliate path riding on it. The scanner is Python the reader keeps and runs offline, and the post says it contacts no model. The pressure that does exist comes from the venue, where agent-safety how-tos travel well and the format rewards a confident general claim over a narrowly tested one.
Half of it re-derivable
The mechanical half survives a second reading: heuristic count, read window, what main() prints, and the fact that the post's own example is caught on filename alone. The other half, that a real client follows a dotenv call into .env, rests on one author's reasoning dressed as an imagined Node service, and one publisher cannot corroborate itself.
build
The release-notes bot that treats its own rate limit as a spec, not an outage1 publisher
build
A deterministic kernel outside the agent loop, because "all tests pass" is not evidence1 publisher
build
AgentCheck reviews what the agent actually changed, and does it without another model1 publisher
build
One shell script before every tool call replaces the permission prompt for headless agents1 publisher
Publishers with included, body-backed reporting in this cluster.
1 article · September 6, 2026