There is a layer every engineering organization ships into production before their code ever reaches an AI agent. We have now audited it across enough mid-size orgs to be uncomfortable about the pattern: it is misconfigured in roughly seven teams out of seven. Fixing it takes an afternoon. Nobody is looking at it.
This is what we call the silent suppressor: a small, systemic configuration problem that sits between the developer, the agent, and the repository, and quietly caps the output of every AI coding tool the organization has paid for. It does not throw errors. It does not produce bad PRs. It simply makes the good PRs never arrive, and leaves the leadership team staring at a flat throughput chart nine months after the Copilot and Cursor seats were approved.
The pattern
Every AI coding tool — Copilot, Cursor, Codex, Claude Code, internally hosted agents — is, underneath, a function from context to proposed diff. The model reads some slice of the repository plus the prompt plus the IDE state, and proposes a change. The quality of the change is a function of the quality of the context.
The silent suppressor is the place in your stack that decides what context the model gets. In most organizations it is one of:
- A pre-commit or CI tool that rewrites or strips docstrings, comments, and type annotations before commits are analyzed.
- A
.gitignore/.cursorignore/.aiignorefile with overly broad entries that hide the exact directories the agent needs to reason about (fixtures, examples, tests, ADRs). - A monorepo tooling layer (Nx, Turborepo, Bazel) with workspace boundaries so strict that the agent never sees cross-package contracts even though every developer has the whole thing checked out.
- An environment with secret-scrubbing pre-processors that, as a side effect, replace configuration identifiers with opaque tokens before the model sees them.
These configurations were written three years ago for good reasons — usually security, noise reduction, or CI performance. Nobody reviewed them when the org adopted agents, because from the tooling team’s point of view nothing changed. The same bytes are flowing through the same pipeline. What changed is that on the other side of the pipeline, a model is now trying to reason over what gets through.
Why nobody notices
The symptom of the silent suppressor is not a bug. It is a lack of uplift.
When engineers run the agent, it produces something. The something compiles, passes the superficial tests, and is merged, or it produces something visibly wrong and gets discarded. In both cases the engineer concludes, correctly, that “the agent wasn’t useful for this task.” Aggregated across the org, this becomes the story that the tools are not ready, or that our repos are too complex, or that we are a special case.
The suppressor is invisible because it is one layer upstream of where anyone is measuring. The platform team is measuring CI performance. The DX team is measuring IDE responsiveness. The engineering leadership is measuring PR throughput. Nobody is measuring context fidelity — how much of the actually relevant repository state is in the window when the model is asked to reason.
How we find it
The readiness assessment we run has a specific diagnostic for this. We ask the organization to run an agent against a task we have constructed to require context from a specific, known subdirectory. Then we instrument the tool to log exactly what it saw. In seven out of seven engagements we have run, the log has revealed that the subdirectory in question was either excluded, collapsed, stripped of the relevant markers, or simply not transported across a monorepo boundary the tool had no visibility into.
The fix, once located, is almost always a single-line change in a configuration file. The conversation with the tooling team takes about thirty minutes. The uplift on the agent’s output the following week is not subtle.
Why this is worth writing down
We are putting this in writing because it is the single most common thing we find, and because it is embarrassingly cheap to check. If your organization is running agents at scale and your delivery curve has not moved, before you blame the model, the repo, or the engineers, spend an afternoon auditing the layer between them.
If you want help doing it structurally — not just for one team but as a scored audit across the portfolio — that is the AI Readiness Assessment. It is a fixed-fee, two-to-four week engagement, written to be exec-ready, and it always starts by looking for the suppressor.