Agents fix the crashes: a post-release pipeline that gives the team its sprint back
Release day plus one. The crash reporter shows a new top issue, a NullPointerException in a screen nobody on call wrote. A senior developer drops planned work to chase it. By day three there are four more, and the sprint plan has quietly become fiction.
The first days after a release are when new crashes cluster: real devices, real data, real network conditions that no test environment fully reproduces. Most of those crashes are not hard. They are a missing null check, a lifecycle race, an unexpected API value. What makes them expensive is the context switch: a person has to stop, load the code into their head, reproduce, fix, test and ship a hotfix.
That pattern is a good fit for coding agents in 2026. Not because an agent is smarter than the developer, but because the work is narrow, repetitive and checkable. The useful design is not "an agent that fixes bugs". It is a pipeline in which the agent does the mechanical part, every step is verified by something other than the agent, and a human makes the final call.
The pipeline
- Collect. Crash events come from the reporter: a webhook, a scheduled export to a data warehouse (Crashlytics streams to BigQuery, Sentry has issue webhooks), or the reporter's API on a timer.
- Dedupe and prioritize. Group by issue fingerprint, then rank. New issues and regressions in the latest version go first, then by affected users. Everything else waits for a human.
- Reproduce as a failing test. The agent gets the stack trace, the release commit and read access to the repo. Its first job is a unit or Robolectric test that fails the same way the crash does. No failing test, no fix.
- Fix. Only now does the agent change production code, with one rule: the new test must pass, and no existing test may be changed or deleted.
- Verify. The normal CI gates run: build, the full test suite, static analysis. A failure goes back to step 4, with a hard cap of three attempts.
- Open a PR. A labelled branch, the stack trace, the failing test, the diff and a short explanation of the root cause in plain language.
- Human review. A developer reads the PR like any other. Merge, request changes or close. The agent never merges.
An issue that fails the loop three times is not dropped. It becomes a ticket with everything the agent learned: the attempts, why they failed and where it looked. That alone saves the human who picks it up a good part of the investigation.
The failing test is the whole point
An agent can produce a fix that makes a crash disappear without understanding it: wrap the call in try/catch, add ?.let and return early, swallow the state. The crash is gone, the bug is now silent. The failing test is what separates a fix from a cover-up: it pins the exact conditions of the crash, and a reviewer can judge whether the test describes the real cause.
Two failure modes are documented well enough to guard against explicitly: an agent writing a test that confirms its own wrong assumption, and an agent "fixing" a red build by editing or deleting the test. The first is caught in review, the second should be impossible: test files outside the new one are read-only for the agent, enforced by the tooling, not by the prompt.
Guardrails
- a maximum number of issues per run and a timeout per issue, so a bad night cannot burn a budget;
- a dry-run mode that produces the analysis without a branch, for the first weeks;
- a restricted tool set: read the repo, run Gradle tasks, write to its own branch; no network beyond what the build needs, no access to production;
- crash data treated as untrusted input: exception messages and log breadcrumbs can carry user-controlled text, which makes them a prompt-injection channel;
- personal data scrubbed from traces and logs before they reach a model hosted outside the company.
Where agents help and where they do not
| Crash type | Agent fit | Why |
|---|---|---|
| Null handling, bad API values | Good | Clear trace, easy to reproduce in a unit test |
| Lifecycle and state races | Medium | Reproducible with Robolectric or coroutine test dispatchers, but the right fix is often architectural |
| Third-party SDK internals | Poor | The bug is not in your code; the useful output is a workaround ticket |
| NDK and native crashes | Poor | Symbols, ABIs and memory state rarely fit in a unit test |
| OOM, ANR | Poor | The trace shows the victim, not the cause |
| Obfuscated trace without mapping | None | Upload R8 mapping files with every release, or nothing downstream works |
| Device or OS specific | Triage only | Grouping by device and OS version is useful, the fix needs a human with the device |
What to measure
Vendor pages for tools like this promise "zero bugs while you sleep". The honest version is a set of numbers you collect yourself from day one and compare after a few releases:
- issues triaged per release, and how many reached a PR;
- PRs merged as is, merged after changes, and closed: the acceptance rate is the real quality signal;
- review time per agent PR compared with a human hotfix;
- the crash-free users rate in the first days after a release, before and after the pipeline;
- developer hours spent on post-release fixes versus planned sprint work;
- cost per merged fix, model usage included.
If the agent rates its own confidence, log that too, and compare it with the acceptance rate. Self-reported confidence is only useful once you know how well it predicts what reviewers actually accept.
What I'd do again, and the mistakes to avoid
What I would keep in any version of this: the failing test as the entry ticket, the three-attempt cap, read-only tests, and a human merge. The real benefit is not that the agent is fast. It is that the team keeps working on planned features while post-release noise is handled in the background and arrives as small, reviewable PRs.
The mistakes to avoid: starting without R8 mapping uploads; letting the agent pick its own issues instead of a ranked queue; measuring "PRs opened" instead of "PRs merged"; skipping the dry-run phase; and treating "the crash is gone" as "the bug is fixed". The pipeline gives the team time back. It does not give it permission to stop reading the code.
Краши чинят агенты: конвейер после релиза, который возвращает команде спринт
Первый день после релиза. В краш-репортере новый топовый краш — NullPointerException на экране, который никто из дежурных не писал. Старший разработчик бросает плановую задачу и идёт разбираться. К третьему дню таких крашей ещё четыре, и план спринта тихо превратился в фантастику.
Первые дни после релиза — время, когда новые краши сыплются кучей: реальные устройства, реальные данные, реальная сеть, которые ни одно тестовое окружение не воспроизводит полностью. Большинство этих крашей несложные: пропущенная проверка на null, гонка в жизненном цикле, неожиданное значение из API. Дорогими их делает переключение контекста: человеку нужно остановиться, загрузить код в голову, воспроизвести, починить, протестировать и выпустить хотфикс.
Для кодовых агентов в 2026 году это подходящая работа. Не потому, что агент умнее разработчика, а потому, что задача узкая, повторяющаяся и проверяемая. Полезная схема — не «агент, который чинит баги». Это конвейер, где агент делает механическую часть, каждый шаг проверяет что-то кроме самого агента, а последнее слово остаётся за человеком.
Конвейер
- Сбор. События крашей приходят из репортера: вебхук, плановый экспорт в хранилище данных (Crashlytics умеет стримить в BigQuery, у Sentry есть вебхуки по issue) или API репортера по таймеру.
- Дедупликация и приоритет. Группируем по отпечатку issue и ранжируем. Сначала новые краши и регрессии в последней версии, потом — по числу затронутых пользователей. Остальное ждёт человека.
- Воспроизведение падающим тестом. Агент получает стектрейс, коммит релиза и доступ к репозиторию на чтение. Его первая задача — unit- или Robolectric-тест, который падает так же, как краш. Нет падающего теста — нет фикса.
- Фикс. Только теперь агент меняет продакшен-код, по одному правилу: новый тест должен пройти, а существующие тесты нельзя ни менять, ни удалять.
- Проверка. Работают обычные шлагбаумы CI: сборка, весь набор тестов, статический анализ. Провал возвращает на шаг 4, жёсткий лимит — три попытки.
- PR. Ветка с меткой, стектрейс, падающий тест, дифф и короткое объяснение причины простыми словами.
- Ревью человеком. Разработчик читает PR как любой другой. Мёрж, просьба о правках или закрытие. Агент никогда не мёржит.
Краш, который трижды не прошёл цикл, не выбрасывается. Он становится задачей со всем, что агент узнал: попытки, почему они не сработали и где он искал. Одно это экономит человеку, который её возьмёт, заметную часть расследования.
Падающий тест — главное
Агент может выдать фикс, после которого краш исчезает, не понимая причины: обернуть вызов в try/catch, добавить ?.let с ранним выходом, проглотить состояние. Краша нет, баг стал тихим. Падающий тест отличает исправление от замазывания: он фиксирует точные условия краша, и ревьюер может оценить, описывает ли тест настоящую причину.
Два сценария провала описаны достаточно хорошо, чтобы защищаться от них явно: агент пишет тест, который подтверждает его собственное неверное предположение, и агент «чинит» красную сборку, правя или удаляя тест. Первое ловится на ревью, второе должно быть невозможным: все тестовые файлы, кроме нового, для агента только на чтение, и это обеспечивает инструментарий, а не промпт.
Ограничители
- максимум крашей за прогон и таймаут на каждый, чтобы неудачная ночь не сожгла бюджет;
- режим dry run на первые недели: анализ без ветки;
- урезанный набор инструментов: читать репозиторий, запускать задачи Gradle, писать в свою ветку; никакой сети сверх нужной сборке и никакого доступа к продакшену;
- данные крашей — недоверенный ввод: сообщения исключений и логи могут содержать текст, который контролирует пользователь, а значит, это канал для prompt injection;
- персональные данные вычищаются из трейсов и логов до того, как попадут в модель, размещённую вне компании.
Где агенты помогают, а где нет
| Тип краша | Подходит агенту | Почему |
|---|---|---|
| Обработка null, плохие значения из API | Хорошо | Понятный трейс, легко воспроизвести в unit-тесте |
| Гонки жизненного цикла и состояния | Средне | Воспроизводятся через Robolectric или тестовые диспетчеры корутин, но правильный фикс часто архитектурный |
| Внутренности сторонних SDK | Плохо | Баг не в вашем коде; полезный результат — задача на обходное решение |
| NDK и нативные краши | Плохо | Символы, ABI и состояние памяти редко помещаются в unit-тест |
| OOM, ANR | Плохо | Трейс показывает жертву, а не причину |
| Обфусцированный трейс без маппинга | Никак | Загружайте маппинг R8 с каждым релизом, иначе дальше ничего не работает |
| Зависит от устройства или версии ОС | Только разбор | Группировка по устройству и версии ОС полезна, но фикс требует человека с устройством |
Что измерять
Сайты таких инструментов обещают «ноль багов, пока вы спите». Честная версия — набор чисел, которые вы собираете сами с первого дня и сравниваете через несколько релизов:
- сколько крашей разобрано за релиз и сколько из них дошло до PR;
- PR, принятые как есть, принятые после правок и закрытые: доля принятых — настоящий сигнал качества;
- время ревью PR от агента в сравнении с хотфиксом от человека;
- доля пользователей без крашей в первые дни после релиза — до конвейера и после;
- часы разработчиков на фиксы после релиза против плановой работы спринта;
- стоимость одного принятого фикса, включая расход модели.
Если агент сам оценивает свою уверенность, логируйте и её и сравнивайте с долей принятых PR. Самооценка полезна только тогда, когда известно, насколько хорошо она предсказывает то, что ревьюеры действительно принимают.
Что я сделал бы снова и каких ошибок избегать
Что я оставил бы в любой версии такого конвейера: падающий тест как входной билет, лимит в три попытки, тесты только на чтение и мёрж человеком. Настоящая польза не в том, что агент быстрый. Она в том, что команда продолжает делать плановые фичи, а шум после релиза разбирается в фоне и приходит маленькими PR, которые легко отревьюить.
Ошибки, которых стоит избегать: начинать без загрузки маппинга R8; позволять агенту самому выбирать краши вместо ранжированной очереди; мерить «открытые PR» вместо «принятых»; пропускать фазу dry run; и считать, что «краш исчез» значит «баг исправлен». Конвейер возвращает команде время. Он не даёт ей права перестать читать код.
— Dmitry