AI agents in an Android team's day: isolated reviewers, a validator and a human who merges
Ask an agent to review the code it has just written, in the same session, and it will usually tell you the code looks good. It is not lying. It is reading its own reasoning back, with the same context, the same assumptions and the same blind spots.
That one failure explains most of what goes wrong when a team "adds AI" to its workflow: one long session that writes, tests and approves its own work. By mid-2026 most Android teams have coding agents in the IDE and in the terminal. The difference between teams that get real value and teams that get noise is not the model. It is the setup around it: what the agent knows, what it is forced to do, who checks it, and who decides.
Four layers of context and control
It helps to stop thinking of "the prompt" and think of layers, each with a different job and a different strength of guarantee.
| Layer | What goes there | Android example |
|---|---|---|
| Rules (CLAUDE.md, AGENTS.md) | Short, always-on facts and conventions | Module map, "state is exposed as StateFlow", "no business logic in Composables" |
| Skills | Procedures loaded only when the task needs them | How to add a feature module, how to write a Room migration with a test |
| MCP servers | Live access to tools and data | Issue tracker, crash reporter, design files, an emulator or device |
| Hooks | Steps that must run, enforced by the harness | Formatter and Detekt after every edit, test files locked during a fix |
The key distinction is between the last row and the first three. Rules, skills and MCP inform the agent; it can still skip a step. A hook enforces: if a step is written only in the prompt, assume it will be skipped one day. Anything that must happen every time (formatting, static analysis, protecting tests from being edited to pass) belongs in a hook or in CI, not in a sentence.
Review: many narrow reviewers, one strict validator
The fix for self-review is isolation. Instead of one reviewer that checks everything, run several narrow ones in parallel, each in a fresh context that contains only the diff, the relevant rules and its own checklist:
- Bugs: null safety, coroutine scope and cancellation, lifecycle leaks, off-by-one, wrong dispatcher.
- Conventions: the team's architecture rules, naming, module boundaries, what static analysis cannot express.
- Security and privacy: logged tokens, exported components, WebView settings, personal data sent to analytics.
- Android specifics: recomposition traps, main-thread I/O, configuration changes, process death and saved state.
Then a separate validator reads all findings and does two things. It rejects every finding without proof: a file, a line and the rule or reasoning that makes it a problem. And it grades what is left: blocking, major or minor. Narrow reviewers are allowed to be noisy; the validator's job is to make the final report short enough that a human actually reads it.
This does not replace human review. It changes what humans review. The machine handles the checklist; the reviewer spends attention on design, product intent and the things no checklist covers. It is the same move teams made years ago with static analysis: once a linter owns the style arguments, they disappear from review comments. Agent reviewers push that line further.
Verification in tiers
An agent that says "tests pass" is a claim. A green CI check is evidence. Verification works best as tiers that get slower and more expensive, so most mistakes die in the cheap ones:
- Seconds: compile, unit tests for the touched modules, Detekt and lint. Run by a hook on every change.
- Minutes: the full unit suite, Compose screenshot tests from previews, Robolectric tests. Run before a PR is opened.
- Tens of minutes: instrumented tests on an emulator, critical user flows. Run in CI on the PR.
- Nightly: real devices or a device farm, different API levels and screen sizes, performance checks.
Each tier is something the agent can call and read, not just something it is told about. An agent that can run the screenshot test and see the diff fixes its own layout mistakes before a human ever looks.
A day with this setup
- Morning: the crash and analytics digest lands as tickets, ranked, with a first analysis attached.
- During the day: developers work with an agent on features; hooks keep formatting, static analysis and fast tests running behind every edit.
- Before a PR: the parallel reviewers and the validator run; the developer fixes blocking items and decides on the rest.
- For QA: the agent turns the diff into a plain-language list of what changed and what to check by hand.
- Merge: a human, every time. No agent grades or merges its own work.
What I'd do again, and the mistakes to avoid
What I would keep in any team: rules short enough to read in a minute, procedures as skills instead of a giant rules file, every must-run step in a hook, reviewers in clean contexts with a validator on top, and the human merge as a hard rule, not a habit.
The mistakes to avoid: one long session that writes and reviews; trusting a step because it is in the prompt; letting an agent edit tests to make them pass; reports that list forty minor findings and hide the one blocking bug; and measuring success by how much code agents produce rather than by how much reviewed, merged work the team ships.
AI-агенты в рабочем дне Android-команды: изолированные ревьюеры, валидатор и человек, который мёржит
Попросите агента отревьюить код, который он только что написал, в той же сессии, и он почти всегда ответит, что всё хорошо. Он не врёт. Он перечитывает собственные рассуждения — с тем же контекстом, теми же допущениями и теми же слепыми зонами.
Эта одна ошибка объясняет большую часть того, что идёт не так, когда команда «добавляет AI» в процесс: одна длинная сессия, которая сама пишет, сама тестирует и сама одобряет свою работу. К середине 2026 года у большинства Android-команд есть кодовые агенты в IDE и в терминале. Разница между командами, которые получают реальную пользу, и командами, которые получают шум, не в модели. Она в обвязке: что агент знает, что его заставляют делать, кто его проверяет и кто принимает решение.
Четыре слоя контекста и контроля
Полезно перестать думать о «промпте» и думать слоями — у каждого своя задача и своя сила гарантии.
| Слой | Что туда кладут | Пример для Android |
|---|---|---|
| Правила (CLAUDE.md, AGENTS.md) | Короткие факты и соглашения, которые действуют всегда | Карта модулей, «состояние наружу — через StateFlow», «никакой бизнес-логики в Composable» |
| Скиллы | Процедуры, которые подгружаются, только когда задача их требует | Как добавить фича-модуль, как написать миграцию Room с тестом |
| MCP-серверы | Живой доступ к инструментам и данным | Трекер задач, краш-репортер, макеты, эмулятор или устройство |
| Хуки | Шаги, которые обязаны выполниться, и это обеспечивает среда | Форматтер и Detekt после каждой правки, тестовые файлы заблокированы во время фикса |
Главное различие — между последней строкой и первыми тремя. Правила, скиллы и MCP агента информируют, и он всё ещё может пропустить шаг. Хук обязывает: если шаг записан только в промпте, считайте, что однажды его пропустят. Всё, что должно происходить каждый раз (форматирование, статический анализ, защита тестов от правок «чтобы прошло»), живёт в хуке или в CI, а не в предложении.
Ревью: много узких ревьюеров и один строгий валидатор
Лекарство от самопроверки — изоляция. Вместо одного ревьюера, который проверяет всё, запускаются несколько узких параллельно, каждый в чистом контексте, где есть только дифф, нужные правила и его собственный чек-лист:
- Баги: null safety, scope и отмена корутин, утечки жизненного цикла, ошибки на единицу, не тот диспетчер.
- Соглашения: архитектурные правила команды, нейминг, границы модулей — то, что статический анализ не умеет выразить.
- Безопасность и приватность: токены в логах, экспортированные компоненты, настройки WebView, персональные данные в аналитике.
- Специфика Android: ловушки рекомпозиции, I/O на главном потоке, смена конфигурации, смерть процесса и сохранённое состояние.
Потом отдельный валидатор читает все находки и делает две вещи. Отклоняет каждую находку без доказательства: файла, строки и правила или рассуждения, из-за которых это проблема. И оценивает оставшееся: blocking, major или minor. Узким ревьюерам разрешено шуметь; задача валидатора — сделать итоговый отчёт настолько коротким, чтобы человек его действительно прочитал.
Это не заменяет ревью человеком. Это меняет то, что человек ревьюит. Чек-лист берёт на себя машина, а ревьюер тратит внимание на дизайн решения, продуктовый замысел и то, что ни в один чек-лист не помещается. Это тот же ход, который команды сделали годы назад со статическим анализом: когда линтер забирает себе споры о стиле, они исчезают из комментариев на ревью. Агенты-ревьюеры двигают эту границу дальше.
Проверка уровнями
Агент, который говорит «тесты проходят», делает заявление. Зелёная проверка в CI — доказательство. Проверка лучше всего работает уровнями, которые становятся всё медленнее и дороже, чтобы большинство ошибок умирало на дешёвых:
- Секунды: компиляция, unit-тесты затронутых модулей, Detekt и lint. Запускает хук на каждое изменение.
- Минуты: весь набор unit-тестов, скриншот-тесты Compose по превью, тесты на Robolectric. Перед открытием PR.
- Десятки минут: инструментальные тесты на эмуляторе, критичные пользовательские сценарии. В CI на PR.
- Ночью: реальные устройства или ферма устройств, разные уровни API и размеры экранов, проверки производительности.
Каждый уровень — это то, что агент может вызвать и прочитать, а не то, о чём ему просто рассказали. Агент, который может запустить скриншот-тест и увидеть разницу, исправляет свои ошибки вёрстки до того, как на них посмотрит человек.
День с такой обвязкой
- Утро: сводка по крашам и аналитике приходит задачами — ранжированными и с первым разбором.
- Днём: разработчики делают фичи вместе с агентом; хуки держат форматирование, статический анализ и быстрые тесты за каждой правкой.
- Перед PR: запускаются параллельные ревьюеры и валидатор; разработчик закрывает blocking и решает, что делать с остальным.
- Для QA: агент превращает дифф в понятный список того, что изменилось и что проверить руками.
- Мёрж: человек, каждый раз. Ни один агент не оценивает и не мёржит собственную работу.
Что я сделал бы снова и каких ошибок избегать
Что я оставил бы в любой команде: правила, которые читаются за минуту; процедуры в скиллах вместо гигантского файла правил; каждый обязательный шаг — в хуке; ревьюеры в чистых контекстах и валидатор над ними; мёрж человеком как жёсткое правило, а не привычка.
Ошибки, которых стоит избегать: одна длинная сессия, которая и пишет, и ревьюит; доверие к шагу только потому, что он есть в промпте; разрешение агенту править тесты, чтобы они прошли; отчёты на сорок minor-находок, за которыми теряется один blocking-баг; и оценка успеха по объёму кода от агентов, а не по объёму проверенной и смёрженной работы, которую команда выпускает.
— Dmitry