Skip the Compressor: Give It the Whole File

Coding agents all work under the same constraint: the repository is far larger than the context window. Two mainstream schools address this. The compression school prunes tokens from code placed in context, keeping the "important" parts. The retrieval school selects code chunks by similarity to the issue. Both assume context is a bag—the more precisely you pack it, the better.

A paper from the University of Illinois Urbana-Champaign asks a more fundamental question first: what does context actually need to fix a bug? Two things, both indispensable:

1. The files to be edited must be in the context. 2. The code in those files must be verbatim—because the model must reproduce, character for character, the lines it intends to edit when generating a patch.

Judged by this standard, both mainstream approaches are flawed. Retrievers rank files by "looks like the issue," not "needs modification"—an irrelevant file may match the issue text closely, while the file that truly needs a fix may share no keywords at all. Compressors keep the right files but rewrite the code—the lines in the model's patch don't exist in the real file, so the patch cannot be applied. The numbers are grim: a substantial fraction of patches produced under compression cannot be applied at all.

A minimal baseline

The paper's method, CQ2-CARE, is almost suspiciously simple:

• Show the model the repository's file path list; have it independently predict, twice, which files must be edited; take the intersection—files named both times are very likely the real targets.
• Put those files into context whole and unmodified.
• Let the model specify a few greps to pull in dependent function definitions and call sites as short snippets.
• No token-level pruning whatsoever.

The controlled evaluation is solid: 300 real open-source issues from SWE-rebench (one repository each), context strictly aligned to the same token budget across methods, patches scored by each benchmark's tests. Baselines: three prompt-compression schemes, three retrieval schemes, and two schemes specifically trained for coding agents.

Results:

• On GPT-5.6, CQ2-CARE solves 43.7% of issues—6.3 points above the best compression method, 9.3 above the best BM25 chunk retrieval.
• On Claude Opus 5, 46.7%—6.3 above compression, 12.7 above retrieval.
• Even the specifically trained systems lose: SweRank trails by 0.7 and 1.7 points; SWE-Pruner by 2.0 and 7.3.

Zero training, no extra models, pure prompt engineering—yet it beat all the specialized approaches.

Two numbers, taken apart

The paper's real methodological contribution is decomposing "context quality" into two quantifiable metrics:

• Golden file recall: how many files that should be edited actually appear in context.
• Verbatim line ratio: how many code lines in context are untouched originals.

Any context-construction scheme has a position on this plane. The paper's sharpest finding comes from a controlled experiment: verbatim fidelity is worth more than recall. Even sacrificing some file recall, keeping included files as complete originals fixes far more bugs than high-recall schemes that corrupt the source.

In other words: packing a little wrong is fine; packing in a forgery is fatal. A model writing patches against compressor-rewritten code is like copying from a retouched photograph—every stroke is diligent, but the signature spells a character that doesn't exist.

This has a much larger resonance. The dominant "context engineering" narrative of the past two years—compression, summarization, pruning—treats context as information, where lossy means some loss. This paper says: for code, context is not information, it is an interface—the model aligns with it literally, and any transcription dirties the interface. Tokens saved by compression are all forfeited to dead patches.

Boundaries and caveats

• Experiments are single-turn patching: the model reads one fixed context and writes one patch—not a full agent that can browse files and run tests. In multi-turn settings where the model can explore, context schemes play a different role.
• Only Python was tested.
• Token budgets were aligned to CQ2-CARE's own operating point—the authors acknowledge this placement choice is debatable.
• Code is not publicly released.

One small finding worth noting: taking the intersection of two independent predictions yields much higher file-level F1 than single sampling—but when single sampling is trimmed to the same file count, solve rates are similar. Double sampling wins by "choosing fewer, more precisely," not by "choosing more correctly." Few and precise: the theme of the whole paper.

---

*Source: arXiv 2610.21073 (2026-10-15), "Skip the Compressor: Coding Agents Fix More Issues When They Pick Whole Files"; University of Illinois Urbana-Champaign; Xiaocong Yang and Rishit Chatterjee co-first authors, with Himanshu Udupi, Vikram Ramavarapu, and ChengXiang Zhai; data: 300 SWE-rebench issues (one repository per issue); models: GPT-5.6 and Claude Opus 5; baselines: LLMLingua-family compression, BM25/dense retrieval, SweRank, SWE-Pruner.*