Inside my agent system for writing Android code
Five-plus years of Android taught me where projects break: vague tasks, untested edge cases, a design that drifts in translation, code that slowly stops looking like one team wrote it. So I built an agent system where each of those has its own gate.
The numbers
- ~60 skills in the app project: 26 top-level ones and their sub-skills. Each one is a short, checkable set of rules with ids, not a wall of advice.
- A dedicated implementer agent for Kotlin Multiplatform and a team of research agents that run in parallel.
- 24 Gradle modules, 94 BDD scenarios in Gherkin, written before the code.
- A code graph of the whole project (GitNexus): 3,300+ symbols, 6,000+ links, 180+ flows. Agents check impact before they touch anything.
The chain, from idea to merge
A feature goes through the same conveyor every time. Bold steps are hard stops: nothing moves on until the gate passes.
- Recon. The agent reads the code graph and the decisions log first, so it does not re-invent or undo what was already decided.
- Research. Up to five researcher agents in parallel, each with its own lens: users, competitors, platform limits.
- PRD. A structured spec, checked by a validator. Too big? The gate splits it into a queue.
- BDD scenarios. Gherkin
.featurefiles with a tag per scenario. Open questions stop the line until I answer them. - Design. The screen is drawn in Penpot and I approve it there. Then it is turned into a text UI reference: colors, sizes, one state per BDD tag.
- Code. A plan pins which skills apply, tests are written first and fail on purpose, then the implementation makes them green.
- Review and style audit. Every fix must cite a rule id. If a pattern keeps coming back, a separate skill turns it into a new rule.
BDD is the backbone
Scenarios in Gherkin are the contract between me, the PRD and the code. They are written before the implementation, the tests start red, and agents may never edit a test to make it pass. More on that in a separate post.
Design straight from the source
The agent talks to the design tool through MCP. I use Penpot MCP: it reads boards, layers and tokens directly. The same slot takes Figma MCP, so a team on Figma plugs in without changing the chain. A hook blocks design calls until the design skill is loaded, so the agent can't improvise around the rules. Code agents never see the design file: they build from the written UI reference, and the result is checked on a real device with a screenshot.
The small things that add up
- Modules with one door. Each feature is split into api and impl with a single UseCase interface. That is why agents can move modules between apps like building blocks.
- Kotlin Multiplatform placement rules: what goes to common, what stays on Android.
- Detekt at zero tolerance and CI pipeline rules kept as a skill, so the agent knows them before it pushes.
- A decisions log. Every engineering call is written down with the reason.
- Session review. After a session, the friction is reviewed and turned into skill changes, each with a changelog entry.
What I do in all this
I set the task, approve the PRD, answer the open questions, sign off the design and review the result. Everything I would say twice becomes a rule. Agents type the code. The engineering stays mine.
Which gate would you add first to your own setup?
Как устроена моя система агентов для Android-разработки
За 5+ лет в Android я понял, где ломаются проекты: размытая задача, непроверенные краевые случаи, дизайн, который искажается по дороге в код, и код, который постепенно перестаёт выглядеть как написанный одной командой. Поэтому я собрал систему агентов, где у каждой из этих проблем свой шлагбаум.
В цифрах
- ~60 скиллов в проекте приложения: 26 основных и их под-скиллы. Каждый — короткий проверяемый набор правил с id, а не простыня советов.
- Отдельный агент-исполнитель под Kotlin Multiplatform и команда агентов-исследователей, которые работают параллельно.
- 24 Gradle-модуля, 94 BDD-сценария на Gherkin, написанные до кода.
- Граф кода всего проекта (GitNexus): 3 300+ символов, 6 000+ связей, 180+ потоков. Агенты проверяют влияние изменений до того, как что-то трогать.
Цепочка от идеи до мержа
Каждая фича проходит один и тот же конвейер. Выделенные шаги — жёсткие остановки: дальше ничего не идёт, пока проверка не пройдена.
- Разведка. Агент сначала читает граф кода и журнал решений, чтобы не изобретать заново и не откатывать то, что уже решено.
- Исследование. До пяти агентов-исследователей параллельно, у каждого свой угол: пользователи, конкуренты, ограничения платформы.
- PRD. Структурированная спека, которую проверяет валидатор. Слишком большая — шлагбаум режет её на очередь.
- BDD-сценарии. Gherkin-файлы
.featureс тегом на каждый сценарий. Открытые вопросы останавливают линию, пока я не отвечу. - Дизайн. Экран рисуется в Penpot, и я утверждаю его там же. Потом он превращается в текстовый UI reference: цвета, размеры, по одному состоянию на каждый BDD-тег.
- Код. План закрепляет, какие скиллы применяются, сначала пишутся тесты и специально падают, потом реализация делает их зелёными.
- Ревью и аудит стиля. Каждая правка должна ссылаться на id правила. Если паттерн повторяется, отдельный скилл превращает его в новое правило.
BDD — это хребет
Сценарии на Gherkin — контракт между мной, PRD и кодом. Они пишутся до реализации, тесты сначала красные, и агентам нельзя править тест, чтобы он прошёл. Подробнее — в отдельном посте.
Дизайн прямо из источника
Агент общается с дизайн-инструментом через MCP. Я использую Penpot MCP: он читает борды, слои и токены напрямую. В тот же слот встаёт Figma MCP, так что команда на Figma подключается без изменений в цепочке. Хук блокирует вызовы дизайна, пока не загружен дизайн-скилл, чтобы агент не импровизировал в обход правил. Агенты, которые пишут код, дизайн-файл не видят: они собирают экран по текстовому UI reference, а результат проверяется на реальном устройстве скриншотом.
Мелочи, из которых всё складывается
- Модули с одной дверью. Каждая фича разделена на api и impl с одним интерфейсом UseCase. Поэтому агенты могут переносить модули между приложениями как детали конструктора.
- Kotlin Multiplatform: правила, что уходит в common, а что остаётся на Android.
- Detekt с нулевой терпимостью и правила CI-пайплайна в виде скилла, чтобы агент знал их до пуша.
- Журнал решений. Каждое инженерное решение записано вместе с причиной.
- Разбор сессий. После сессии трения разбираются и превращаются в изменения скиллов, каждое с записью в changelog.
Что в этом делаю я
Ставлю задачу, утверждаю PRD, отвечаю на открытые вопросы, принимаю дизайн и ревьюю результат. Всё, что я сказал бы дважды, становится правилом. Код набирают агенты. Инженерия остаётся за мной.
Какой шлагбаум вы бы добавили в свой процесс первым?
— Dmitry