SWE-at-Scale: Scalable Issue Synthesis from Historical Bug Fixes

SWE-at-Scale. Scalable Issue Synthesis from Historical Bug Fixes. By Silin Chen and nine others, from Shanghai Jiao Tong University, North China Electric Power University, and four other institutions. Published on the fifteenth of October. Its code repository is public and real: ten source files.

As coding agents become more capable, evaluating them robustly calls for a broader and more diverse supply of verifiable software engineering tasks. Real tasks are constrained in two ways. They arrive only as often as issues are naturally reported, and curating them by hand carries a substantial cost. Synthetic approaches exist, but they rely mainly on the pretrained knowledge of large models, coupled with heuristic prompting, and they often fail to capture the authentic, complex mechanics of how software actually fails. A bug a model invents from what it already knows is not the same thing as a bug that real development produced.

SWE-at-Scale automatically synthesizes realistic issues by reverse-engineering real-world software fixes. The key insight is that a historical fix encapsulates deep mechanistic knowledge of how the bug formed. Invert the fix, and repair supervision becomes bug-induction supervision. Instead of learning how a problem was solved, the system learns how it was introduced, and that knowledge stays grounded in actual development scenarios.

The framework then transfers these learned bug patterns to novel code contexts. It repeatedly samples diverse bug typologies, and from them it constructs executable software engineering tasks. A fix observed once, in one place, becomes a pattern that can be planted somewhere new. The aim is to scale task production exponentially, rather than at the pace of issue reports and manual curation.

Extensive experiments show that SWE-at-Scale generates more diverse and more realistic tasks than current synthesis baselines, and that its tasks pose greater challenges to state-of-the-art coding agents. Diversity holds even within a single code context: the framework can generate distinct bug types from one context, and bug diversity keeps scaling robustly even up to two hundred generations per file.

The supply problem gets reframed. Real fixes are finite, and they accumulate only as fast as developers report and repair bugs. Read backwards, though, each fix is a lesson in how code breaks. SWE-at-Scale turns that finite record into reusable supervision, and from it synthesizes tasks that are realistic, diverse and challenging, at a scale the original record could never supply on its own.