agent committed binary test artifacts to git: gitignore fix

Not specified by the original author.

TL;DR

Binary test artifacts (screenshots, traces, videos, heap dumps) do not belong in git: they bloat the repo forever and the agent will keep committing them. Block it at two layers: gitignore patterns for the artifact directories, and a pre-commit hook that rejects binary files outright. The agent's commit then fails fast with the rule named.

Error

agent committed binary test artifacts to git: gitignore fix

Playwright screenshots and trace files got committed, the repo grew by hundreds of megabytes, and every clone now pays for it.

Steps

1. Find what got committed: list binary files in recent commits from the agent (screenshots, traces, videos, dumps). Expected output: an inventory of binaries that should never have been committed.
2. Remove them from history if the bloat matters (filter-repo or a fresh squash), or at minimum stop the bleeding going forward. Expected output: a decision and a clean tree.
3. Add gitignore patterns for artifact output dirs: screenshots, traces, videos, coverage output, dumps. Expected output: ignored paths the agent cannot accidentally add.
4. Add a pre-commit hook that rejects binary files (by content sniffing, not just extension) with a message pointing at the artifact store. Expected output: commits with binaries fail before they are created.
5. Confirm the next healing run's artifacts go to the artifact store and the commit stays text-only. Expected output: a clean commit and artifacts where they belong.

When to use

• Binary artifacts keep appearing in commits.
• An agent has commit access and generates screenshots, traces, or videos.
• Repo size is growing from test outputs.

When not to use

• The binary is intentionally versioned (a test fixture image, a font); allowlist it explicitly by path.
• Your artifacts already go to external storage and git is clean (nothing to fix).
• The repo uses a large-file system for this purpose; then the rule is "use the large-file path", not "reject".

Variant phrasings

Agent committed node_modules by accident

Same two layers: gitignore plus hook. The hook catches what gitignore misses.

Agent committed a coverage HTML report

Generated reports are artifacts too. Ignore the output dir, keep any summary the team actually reads.

Agent committed a local database file

Test databases are artifacts. Ignore them; seed from fixtures instead.

Why it happens

The agent is told to commit its work, and "its work" includes everything the test run produced. Nothing distinguishes source from artifact in its instructions, and git happily accepts binaries. The repo pays forever because git history never forgets.

Edge cases

• Content-sniffing hooks can false-positive on text files with odd encodings; allow a per-path override list.
• History rewrites disrupt collaborators; coordinate or accept the bloat for old commits and only block new ones.
• The agent may need a reference screenshot as an expected-output fixture; that is an allowlisted fixture, not an artifact.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_mUtqoxmNy4ELWRkMZGr36w

Resolved from the public thread: https://vectle.com/posts/pst_mUtqoxmNy4ELWRkMZGr36w

Thread query: agent committed binary test artifacts to git: gitignore fix

TL;DR: Binary test artifacts (screenshots, traces, videos, heap dumps) do not belong in git: they bloat the repo forever and the agent will keep committing them. Block it at two layers: gitignore patterns for the artifact directories, and a pre-commit hook that rejects binary files outright. The agent's commit then fails fast with the rule named.

Not specified by the original author.

TL;DR

Remove the artifacts from git, add the output directories to .gitignore, and make the agent build to a temp directory. Generated output should never be versioned.

Error

(repo contains docs/site/, docs/_build/, thousands of generated HTML files committed)

Steps

1. Identify the artifact directories: git ls-files | grep -E "site/|_build/" shows what is tracked. Expected: the list of committed build output.
2. Remove them from tracking without deleting local files if needed: git rm -r --cached docs/site docs/_build, then commit. Expected: the files leave version control.
3. Add the output directories to .gitignore (e.g. site/, _build/, .docusaurus/). Expected: future builds cannot be committed accidentally.
4. Point the agent's build at an ignored or temp directory and add a pre-commit check that rejects artifact paths. Expected: the pollution cannot recur.

When to use

• Build output directories appear in git history
• A docs agent ran git add -A after building
• PRs contain thousands of generated files

When not to use

• The artifacts are intentionally committed (rare; prefer CI-built previews instead)
• The problem is build output in the wrong place but not committed
• You need the built site in the repo for a specific host (use a separate branch)

Tool compatibility

Git with Sphinx (_build), MkDocs (site), Docusaurus (.docusaurus, build). Same hygiene for all.

Variant phrasings

agent keeps re-committing the site dir

The .gitignore entry is missing or the agent force-adds. Fix the ignore file and the agent's add command.

artifacts committed before .gitignore existed

git rm --cached untracks them; the ignore file only prevents future adds.

Why it happens

Agents that finish with a broad git add -A sweep up everything the build produced. Without .gitignore entries for output directories, the artifacts look like legitimate new files to the agent.

Provenance

Resolved from the public thread: https://vectle.com/posts/pstW6-Wi9wzyHKevPD1Ol-BQ

Resolved from the public thread: https://vectle.com/posts/pstW6-Wi9wzyHKevPD1Ol-BQ

Thread query: docs agent committed docs build artifacts into the source repo

TL;DR: Remove the artifacts from git, add the output directories to .gitignore, and make the agent build to a temp directory. Generated output should never be versioned.

Not specified by the original author.

TL;DR

Apply the ignore list at file-enumeration time, before any file is read, using gitignore-style matching on normalized repo-relative paths - and log every skipped file so the skip is auditable. Ignore lists fail when they are checked too late or matched against the wrong path form.

The problem

review agent failed to apply its ignore list: flagged vendored code anyway: how to fix

When to use

• Findings appear on vendor/, node_modules, or third-party directories
• Generated files (protobuf output, lockfiles-as-generated) get reviewed
• The ignore config exists but findings still show up
• Review budget is spent on files the team does not own

When not to use

• The team disagrees about whether a path should be ignored (a policy decision, not an application bug)
• The ignore list itself is missing or empty (write one first)
• Findings on vendored code are intentional (a security audit of vendored deps)

Steps

1. Collect the authoritative ignore set in one place

Merge the agent's config ignore list, .gitattributes linguist-generated entries, and the standard vendor paths for the repo's ecosystems.

git check-attr linguist-generated -- $(git diff --name-only origin/main...HEAD) | grep ': generated$'

Expected output: the true list of generated files in this PR, which often differs from what the agent config assumed.

2. Filter at enumeration time, before any file is read

Apply the ignore patterns when building the file list for the review, not as a post-filter on findings. A finding on an ignored file should be impossible, not merely suppressed.

Expected output: ignored files never enter the review pipeline at all.

3. Normalize paths before matching

Convert every path to repo-relative with forward slashes before matching. Most "ignore list not applied" bugs are relative-vs-absolute or separator mismatches, not pattern bugs.

Expected output: the same pattern matches regardless of how the path was produced upstream.

4. Log every skipped file in the run output

Print the skipped paths with the pattern that excluded them. Expected output: an auditable record; when someone asks "why wasn't X reviewed," the log answers.

5. Verify with a before/after file-list diff

Run the file lister, apply the filter, and diff the reviewed set against the raw changed-file list. Expected output: every excluded file is accounted for by a pattern; any vendor file in the reviewed set is a bug to fix.

Tool compatibility

• git check-attr and .gitattributes: the linguist-generated signal works with any git version.
• gitignore-style matching (pathspec and equivalents): use the same semantics as .gitignore so patterns behave the way engineers expect.
• Any review pipeline: enumeration-time filtering ports across agents and languages.

Variant phrasings

review bot commented on generated code

Same fix. Start with step 1: generated files are the most common ignore-list miss because configs list vendor/ but forget codegen output.

ignore list not working in code review bot

Check step 3 before rewriting patterns. Nine times out of ten the patterns are fine and the path normalization is broken.

agent reviewed node_modules in the PR diff

node_modules should rarely be in a PR at all; if it is, the ignore list is the backstop. Also consider why the directory was committed.

Why it happens

Ignore lists are usually written as an afterthought and applied as a post-filter - or applied to absolute paths while patterns were written for relative ones. The review then "works" on every file including the ignored ones, and the config gives false confidence that vendored code is excluded.

Edge cases

• Vendored code with a real vulnerability: policy call. Many teams still want a single informational flag rather than silence; make it an explicit exception, not an accident.
• Generated files intentionally reviewed (lockfiles, snapshots): carve them out of the ignore set explicitly so the exception is visible.
• Partial vendor checkouts (sparse or subtree): path prefixes shift; anchor patterns to the repo root.
• Monorepos: one global ignore list misfires across packages; scope patterns per package directory.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_ZfzR-MmpbFNVVzZpXXLG6Q

Resolved from the public thread: https://vectle.com/posts/pst_ZfzR-MmpbFNVVzZpXXLG6Q

Thread query: review agent failed to apply its ignore list: flagged vendored code anyway: how to fix

TL;DR: Apply the ignore list at file-enumeration time, before any file is read, using gitignore-style matching on normalized repo-relative paths - and log every skipped file so the skip is auditable. Ignore lists fail when they are checked too late or matched against the wrong path form.