AI agents

Agents fix the crashes: a post-release pipeline that gives the team its sprint back

#AIagents #Android #Crashes #Automation

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

the agent works in the middle, a human owns the end
  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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

Where agents help and where they do not

Crash typeAgent fitWhy
Null handling, bad API valuesGoodClear trace, easy to reproduce in a unit test
Lifecycle and state racesMediumReproducible with Robolectric or coroutine test dispatchers, but the right fix is often architectural
Third-party SDK internalsPoorThe bug is not in your code; the useful output is a workaround ticket
NDK and native crashesPoorSymbols, ABIs and memory state rarely fit in a unit test
OOM, ANRPoorThe trace shows the victim, not the cause
Obfuscated trace without mappingNoneUpload R8 mapping files with every release, or nothing downstream works
Device or OS specificTriage onlyGrouping 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:

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.

Краши чинят агенты: конвейер после релиза, который возвращает команде спринт

#AIagents #Android #Crashes #Automation

Первый день после релиза. В краш-репортере новый топовый краш — NullPointerException на экране, который никто из дежурных не писал. Старший разработчик бросает плановую задачу и идёт разбираться. К третьему дню таких крашей ещё четыре, и план спринта тихо превратился в фантастику.

Первые дни после релиза — время, когда новые краши сыплются кучей: реальные устройства, реальные данные, реальная сеть, которые ни одно тестовое окружение не воспроизводит полностью. Большинство этих крашей несложные: пропущенная проверка на null, гонка в жизненном цикле, неожиданное значение из API. Дорогими их делает переключение контекста: человеку нужно остановиться, загрузить код в голову, воспроизвести, починить, протестировать и выпустить хотфикс.

Для кодовых агентов в 2026 году это подходящая работа. Не потому, что агент умнее разработчика, а потому, что задача узкая, повторяющаяся и проверяемая. Полезная схема — не «агент, который чинит баги». Это конвейер, где агент делает механическую часть, каждый шаг проверяет что-то кроме самого агента, а последнее слово остаётся за человеком.

Конвейер

агент работает в середине, конец принадлежит человеку
  1. Сбор. События крашей приходят из репортера: вебхук, плановый экспорт в хранилище данных (Crashlytics умеет стримить в BigQuery, у Sentry есть вебхуки по issue) или API репортера по таймеру.
  2. Дедупликация и приоритет. Группируем по отпечатку issue и ранжируем. Сначала новые краши и регрессии в последней версии, потом — по числу затронутых пользователей. Остальное ждёт человека.
  3. Воспроизведение падающим тестом. Агент получает стектрейс, коммит релиза и доступ к репозиторию на чтение. Его первая задача — unit- или Robolectric-тест, который падает так же, как краш. Нет падающего теста — нет фикса.
  4. Фикс. Только теперь агент меняет продакшен-код, по одному правилу: новый тест должен пройти, а существующие тесты нельзя ни менять, ни удалять.
  5. Проверка. Работают обычные шлагбаумы CI: сборка, весь набор тестов, статический анализ. Провал возвращает на шаг 4, жёсткий лимит — три попытки.
  6. PR. Ветка с меткой, стектрейс, падающий тест, дифф и короткое объяснение причины простыми словами.
  7. Ревью человеком. Разработчик читает PR как любой другой. Мёрж, просьба о правках или закрытие. Агент никогда не мёржит.

Краш, который трижды не прошёл цикл, не выбрасывается. Он становится задачей со всем, что агент узнал: попытки, почему они не сработали и где он искал. Одно это экономит человеку, который её возьмёт, заметную часть расследования.

Падающий тест — главное

Агент может выдать фикс, после которого краш исчезает, не понимая причины: обернуть вызов в try/catch, добавить ?.let с ранним выходом, проглотить состояние. Краша нет, баг стал тихим. Падающий тест отличает исправление от замазывания: он фиксирует точные условия краша, и ревьюер может оценить, описывает ли тест настоящую причину.

Два сценария провала описаны достаточно хорошо, чтобы защищаться от них явно: агент пишет тест, который подтверждает его собственное неверное предположение, и агент «чинит» красную сборку, правя или удаляя тест. Первое ловится на ревью, второе должно быть невозможным: все тестовые файлы, кроме нового, для агента только на чтение, и это обеспечивает инструментарий, а не промпт.

Ограничители

Где агенты помогают, а где нет

Тип крашаПодходит агентуПочему
Обработка null, плохие значения из APIХорошоПонятный трейс, легко воспроизвести в unit-тесте
Гонки жизненного цикла и состоянияСреднеВоспроизводятся через Robolectric или тестовые диспетчеры корутин, но правильный фикс часто архитектурный
Внутренности сторонних SDKПлохоБаг не в вашем коде; полезный результат — задача на обходное решение
NDK и нативные крашиПлохоСимволы, ABI и состояние памяти редко помещаются в unit-тест
OOM, ANRПлохоТрейс показывает жертву, а не причину
Обфусцированный трейс без маппингаНикакЗагружайте маппинг R8 с каждым релизом, иначе дальше ничего не работает
Зависит от устройства или версии ОСТолько разборГруппировка по устройству и версии ОС полезна, но фикс требует человека с устройством

Что измерять

Сайты таких инструментов обещают «ноль багов, пока вы спите». Честная версия — набор чисел, которые вы собираете сами с первого дня и сравниваете через несколько релизов:

Если агент сам оценивает свою уверенность, логируйте и её и сравнивайте с долей принятых PR. Самооценка полезна только тогда, когда известно, насколько хорошо она предсказывает то, что ревьюеры действительно принимают.

Что я сделал бы снова и каких ошибок избегать

Что я оставил бы в любой версии такого конвейера: падающий тест как входной билет, лимит в три попытки, тесты только на чтение и мёрж человеком. Настоящая польза не в том, что агент быстрый. Она в том, что команда продолжает делать плановые фичи, а шум после релиза разбирается в фоне и приходит маленькими PR, которые легко отревьюить.

Ошибки, которых стоит избегать: начинать без загрузки маппинга R8; позволять агенту самому выбирать краши вместо ранжированной очереди; мерить «открытые PR» вместо «принятых»; пропускать фазу dry run; и считать, что «краш исчез» значит «баг исправлен». Конвейер возвращает команде время. Он не даёт ей права перестать читать код.

— Dmitry