undercode_
  1. Главная
  2. Блог
  3. ИИ для создания приложений: как работать с агентами и проверять результат
Робот собирает приложение из блоков рядом с базой данных под замком, человек отмечает пункты проверки в списке

Кейс16 мин чтения

ИИ для создания приложений: как работать с агентами и проверять результат

Как собрать приложение с помощью ИИ-агентов: план, схема данных, права доступа, секреты, тесты и ревью другой моделью на живом примере.

Содержание · 10 разделов

ИИ для создания приложений уже пишет рабочий код, поднимает инфраструктуру и прогоняет тесты. Сложности начинаются, когда в приложении появляются данные, пользователи и права: код «вроде работает», а потом выясняется, что чужую запись можно прочитать, фоновая задача тихо умерла, а проверку обошёл хук Git.

С октября 2026 года я собираю ИИ-агентами SEO-кабинет для статей этого блога. Ниже путь, который у меня сложился: требования, данные и права, код, тесты с фактическим результатом, ревью другой моделью, выпуск и откат. С реальными поломками и с тем, как их поймали.

Что ИИ умеет в создании приложений сейчас

Для этой статьи инструменты удобно разделить на два сценария работы, и от сценария зависит, сколько решений останется за вами.

Конструкторы с агентом. Пример: Replit Agent. По документации Replit агент пишет код, настраивает инфраструктуру и тестирует результат. Там же есть режим плана, в котором можно обсудить и расписать проект до того, как агент изменит код или данные. Агент по ходу работы создаёт контрольные точки, к которым можно откатиться. В описании контрольных точек отдельно сказано, что точка хранит данные и схему базы, а восстановление содержимого базы при откате выбирается отдельной опцией. Откат кода и откат данных у вас разные решения.

Кодовые агенты в репозитории. Claude Code, Codex, GitHub Copilot работают с вашим кодом, тестами и Git. Здесь больше контроля и больше ответственности. В карточке GitHub Copilot Agents прямо написано, что сгенерированный код нужно внимательно проверять и тестировать, особенно в критичных и чувствительных приложениях, а всё, что сделал агент, просматривать до слияния.

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

Мой случай коротко

Кабинет статей блога пишут агенты: код делают Claude и Codex, а ревью ведёт GPT как отдельный рецензент, который этот код не писал (для кода Claude это ещё и модель другого семейства). Я ставлю задачи, пишу критерии приёмки и нажимаю кнопки на точках остановки. На третьем этапе это было приложение на стандартной библиотеке Python от версии 3.9 и SQLite: доска из 11 стадий статьи, проверки выхода из каждой стадии, материалы с цитатами. На четвёртом этапе добавились три отдельные очереди заданий (сайт, SEOMEAT, инструменты), чтобы многочасовое ожидание одной из них не держало публикацию.

Как устроен и собирается сам агент, я разбирал в статье как создать ИИ-агента. Здесь речь о приложении, которое агенты строят.

План до первой строки кода

Агент без рамок расширяет задачу сам. Поэтому до кода у меня появляется короткая спецификация из трёх частей.

  1. Критерий приёмки одной фразой. В спецификации MVP кабинета он звучал так: «Одна настоящая новая статья проходит в кабинете на ноде весь путь от темы до живой страницы». И уточнение: все шаги выполняются ручными кнопками, автопилот выключен. Такая фраза проверяется одним прогоном, без споров о том, «готово или почти».
  2. Список «не входит». В моём MVP туда ушли этапы автопилота, исполнители на отдельной машине, автопубликация и ещё несколько пунктов. Когда агент предлагает «заодно сделать», есть куда это записать вместо кода.
  3. Точки остановки. Установка на сервер, каждый выпуск статьи на сайт и любой платный запуск требуют отдельного «ок» владельца. Агент доходит до точки и ждёт.

К приёмке добавились два технических условия: тесты сервиса зелёные на Python 3.9 и 3.13, а ревью кода (инженерное и по безопасности) закрыто без открытых P0 и P1. То есть без найденных проблем высшего и высокого приоритета.

Инструменты это поддерживают. В Claude Code есть режим плана: агент читает файлы и предлагает план, но ничего не правит, пока вы его не одобрите. У Replit, как уже сказано, похожий режим перед изменением кода и данных.

Данные и кто пишет в базу

Схему данных стоит описать до кода и сразу заложить в неё владельца записи. Иначе агент сделает таблицу, где запись принадлежит «всем», и проверку прав придётся прикручивать сверху.

Минимальный пример схемы, где у каждой записи есть владелец:

CREATE TABLE users (
  id INTEGER PRIMARY KEY,
  name TEXT NOT NULL
);

CREATE TABLE notes (
  id INTEGER PRIMARY KEY,
  owner_id INTEGER NOT NULL REFERENCES users(id),
  body TEXT NOT NULL,
  created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
);

CREATE INDEX notes_owner ON notes(owner_id);

Второй вопрос: кто и как пишет в базу. С SQLite это особенно важно. В документации по WAL сказано, что в этом режиме читатели не блокируют писателя и писатель не блокирует читателей, но писатель одновременно может быть только один. Там же: все процессы, работающие с базой, должны быть на одной машине, через сетевую файловую систему WAL не работает.

Если писатель занят, остальные ждут. Сколько ждут, задаёт busy_timeout: если блокировку снимут раньше, запись продолжится, а если она держится дольше заданного числа миллисекунд, обработчик перестаёт ждать и операция возвращает SQLITE_BUSY. Таймаут даёт время дождаться писателя, но успешной записи не гарантирует. Код должен быть готов к тому, что запись не прошла. В Python ожидание удобно задать прагмой busy_timeout: по документации SQLite она заменяет эту C-функцию для языковых привязок, а обработчик ожидания у соединения может быть только один.

import sqlite3

def open_db(db_path):
    conn = sqlite3.connect(db_path)
    conn.execute("PRAGMA journal_mode=WAL")
    conn.execute("PRAGMA busy_timeout=5000")
    return conn

Случай «database is locked»

3 ноября 2026 года у меня в кабинете умер поток публикации. В журнале: sqlite3.OperationalError: database is locked в момент, когда задание забиралось из очереди и открывалась пишущая транзакция BEGIN IMMEDIATE. HTTP кабинета при этом продолжал отвечать. Причину конкурирующей записи установить не удалось.

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

Вывод для любого приложения с фоновыми задачами: ответ «сервис жив» на HTTP-запрос ничего не говорит о том, живы ли фоновые потоки. Проверять нужно отдельно, по каждому потоку.

Права доступа по умолчанию закрыты

Права доступа агенту нужно прописать явно, до кода. В OWASP A01:2025 три правила, которые я переношу в задание агенту почти дословно:

  • контроль доступа работает, только когда он реализован в доверенном серверном коде, где атакующий не может изменить проверку;
  • всё, кроме публичных ресурсов, по умолчанию запрещено;
  • модель доступа должна проверять, кому принадлежит запись; иначе любой пользователь сможет создавать, читать, менять и удалять любые записи.

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

def get_note(conn, note_id, user_id):
    row = conn.execute(
        "SELECT id, body FROM notes WHERE id = ? AND owner_id = ?",
        (note_id, user_id),
    ).fetchone()
    if row is None:
        raise PermissionError("note is missing or belongs to another user")
    return row

Как устроен доступ агента в моём кабинете

Агент обращается к кабинету по токену, и у токена есть явный список разрешённых действий: материалы, сохранение и продвижение карточки по стадиям, запуск проверок и ревью. Отдельно перечислено запрещённое, это кнопки владельца: публикация, обновление, удаление, восстановление, отклонение, создание новой карточки и настройки. Неизвестный путь тоже запрещён. Правило редакции короткое: опубликовать может только владелец своей кнопкой, токену запрос на публикацию возвращает 403. Этот контракт я сверял с установленным кодом 31 октября 2026 года.

Общий принцип выглядит так:

AGENT_ALLOWED = {"/materials", "/save", "/advance", "/review_run"}

def agent_may(path):
    # всё, чего нет в списке, включая неизвестные пути, запрещено
    return path in AGENT_ALLOWED

Здесь работает именно список разрешённого. Новый путь, который агент добавит завтра, будет закрыт, пока его явно не откроют.

Секреты не живут в коде

Шпаргалка OWASP по управлению секретами начинается с неприятного наблюдения: многие организации держат секреты прямо в исходном коде открытым текстом, в конфигах и в инструментах управления конфигурацией. Там же два практических совета. Включить поиск секретов на стороне разработчика, чтобы они не попали в коммит, например через pre-commit хук. И не зашивать секреты в docker ENV и docker ARG, потому что они легко утекают вместе с описанием контейнера.

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

В примерах кода, которые генерирует агент, удобно сразу требовать чтение из окружения:

import os

MCP_TOKEN = os.environ["MCP_TOKEN"]

Тесты, которые ловят ошибки агента

Тесты у агента нужны по той же причине, что и у людей. В главе про тестирование из книги Software Engineering at Google сказано, что автоматические тесты могут не дать ошибкам дойти до пользователей, что они заставляют разобраться с проблемами рано и что тестирование не может быть делом «на потом». С агентом это острее: код появляется быстро, и без тестов вы узнаёте о поломке от пользователя.

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

Тесты в инструкции агента

Запишите агенту точные команды запуска тестов, а потом проверяйте, что он их действительно запустил и что они прошли. В рекомендациях по Claude Code советуют записать в CLAUDE.md, как подтвердить работу в репозитории: точные команды тестов, проверки типов и линтера, и как запустить один тестовый файл. Codex читает AGENTS.md до начала любой работы, и в примерах OpenAI там стоит правило вроде «всегда запускай npm test после изменения файлов JavaScript». Подробнее про Codex и AGENTS.md я писал в статье про OpenAI Codex.

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

Проверка изменений
- После любой правки запускай: python -m pytest
- На каждое изменение прав добавляй тест, где чужой пользователь получает отказ.
- Миграции схемы и выкладку сам не запускай: остановись и спроси.

И отдельно про пограничные случаи. В описании рабочих сценариев Claude Code советуют формулировать, какое именно поведение проверить, и просить агента найти пограничные случаи, которые вы могли упустить. Для схемы выше это негативный тест доступа. Переменная SCHEMA в нём содержит SQL из раздела про данные, а get_note импортируется из модуля приложения (здесь он условно назван app):

import sqlite3
import pytest

from app import get_note  # функция из раздела про права

SCHEMA = """
CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT NOT NULL);
CREATE TABLE notes (
  id INTEGER PRIMARY KEY,
  owner_id INTEGER NOT NULL REFERENCES users(id),
  body TEXT NOT NULL,
  created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
);
"""

def test_foreign_note_is_denied():
    conn = sqlite3.connect(":memory:")
    conn.executescript(SCHEMA)
    conn.execute("INSERT INTO users (id, name) VALUES (1, 'a'), (2, 'b')")
    conn.execute("INSERT INTO notes (id, owner_id, body) VALUES (10, 1, 'x')")
    with pytest.raises(PermissionError):
        get_note(conn, 10, user_id=2)

Как это работало у меня

Правило простое: каждая находка ревью получает тест, который падает на старой версии и проходит на новой. На третьем этапе контрольная проверка исправлений подтвердила все 6 правок цикла: каждая падает на версии 1.2 и проходит на 1.3, регрессий нет, тесты 111 из 111. После исправления выкладки (о нём ниже) стало 116 из 116. В заметке четвёртого этапа: 120 из 120 для третьего этапа и 97 из 97 для четвёртого, на Python 3.9 и 3.13, плюс мутационные проверки. Для одного исправления я записал отдельно: если вернуть старый путь отказа, его ловят 4 теста из 4.

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

Ревью другой моделью

Автор кода плохо проверяет сам себя. В главе 9 книги Google ревью кода определено как проверка кем-то, кроме автора, обычно до того, как изменение попадёт в кодовую базу. Для агентов Anthropic описывает тот же принцип: команда ревью смотрит diff в свежем субагенте, который не видел вашего разговора, и рассуждения, которые привели к коду, на него не влияют.

У меня код пишут агенты Claude и Codex, а ревью ведёт GPT как отдельный независимый рецензент. Критерий блокирующий: пока есть открытые P0 или P1, этап не принят.

Как это выглядело на деле:

ЭтапЧто нашёл рецензентИтог
Этап 3, первый кругНесогласие по четырём линиям: обход пути через имя статьи, пять проблем с транзакциями Git, импорт статей сайта, ещё один обход пути, вёрстка на ширине 320pxВсё исправлено в версии 1.1
Этап 4, три круга9 P1, затем 3 P1, затем 0 P1P2 закрыты, кроме одного: поток проверки медленной ссылки живёт до 30 секунд после срока
Повторный аудит, 12.11.20261 P0 и 3 P1, в работе не проявились; из 17 пунктов аудита закрыто 14, частично 3Установка исправлений только после вопроса владельцу

Путь до root, который нашёл рецензент

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

Исправление сузило выкладку: она проходит, только если между текущим состоянием основной ветки на сервере и новым коммитом изменились одни файлы статей, а скрипты сборки остались прежними. Это проверили в песочнице на сервере: статья проходит, а изменённый скрипт выкладки, символическая ссылка, плохое имя и подпапка получают отказ. Тесты после этого 116 из 116. Второй круг ревью закрыл P1 и три P2, обхода фильтра выкладки не нашлось.

Внешний рецензент не заменяет остальные барьеры. В документации Codex по ревью pull request так и сказано: правила ревью направляют Codex, но не заменяют тесты, защиту веток и обязательные согласования. А GitHub советует дополнять ревью Copilot внимательным ревью человеком.

Если вы дошли до этого места и собираете похожее у себя, загляните в бот UnderCode: это бот автора блога.

Что ломалось при разработке и в работе

Тесты ловят не всё. Два случая ниже всплыли в работе, один нашло ревью.

Два агента собрали один этап в одну ветку. В журнале у меня запись о конфликте ветки: этап 4 собран дважды. Причина нашлась в самой панели задач: Multica при создании задачи, назначенной агенту, сама запускает отдельный прогон того же агента в своей папке, и он писал в ту же ветку и в папку проекта. Решение владельца: основой этапа взяли одну версию, параллельную отбросили. Урок: перед большой работой смотреть, какие прогоны уже идут по задаче. Как управлять несколькими агентами из одной панели, я разбирал в статье про несколько ИИ-агентов в Multica.

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

Перезапуск вернул очередь, но дефект не исправил. Это случай с «database is locked» из раздела про данные. После перезапуска всё выглядит нормально, и соблазн закрыть инцидент велик, хотя причина конкурирующей записи так и не установлена.

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

Чек-лист перед тем, как доверить агенту приложение с данными

Каждый пункт можно проверить и отметить:

  1. Критерий приёмки записан одной фразой и проверяется одним прогоном.
  2. Есть список того, что не входит в задачу, и точки остановки, где агент ждёт вашего решения.
  3. Для каждой сущности описана модель доступа: где запись принадлежит пользователю, владелец проверяется в запросе к базе на сервере, а идентификатор пользователя берётся из проверенной сессии.
  4. Доступ агента и пользователей построен на списке разрешённого, неизвестный путь возвращает отказ.
  5. Перечислены критичные операции (например, публикация, удаление, настройки) и роли, которым они разрешены. В моём кабинете токен агента получает на них 403.
  6. Секретов нет в коде и в репозитории, перед коммитом работает поиск секретов.
  7. Для базы понятно, кто пишет и что происходит при SQLITE_BUSY, а фоновые задачи проверяются отдельно от HTTP.
  8. Команды тестов записаны в CLAUDE.md или AGENTS.md, а критичные правила закреплены хуками и запретами.
  9. Каждая находка ревью получает тест, который падает на старой версии и проходит на новой, включая негативные тесты доступа.
  10. Ревью делает другая модель или человек, и открытые P0 и P1 блокируют выпуск; откат кода и данных продуман заранее.

Частые вопросы

Можно ли создать приложение с помощью ИИ без программирования

Прототип собрать можно без своего кода: Replit Agent по документации сам пишет код, настраивает инфраструктуру и тестирует результат. Решения о данных, правах и выпуске всё равно остаются за вами, а чтобы проверить права, базу, секреты и выкладку перед реальными пользователями, может понадобиться технический специалист.

Какой ИИ выбрать для создания приложений

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

Можно ли выкладывать то, что сделал агент, сразу

GitHub советует просматривать всё, что сделал агент, до слияния. У меня каждый выпуск статьи на сайт и любая установка требуют отдельного «ок» владельца, а повторный аудит даже работающего кабинета нашёл P0 и три P1, которые в работе не проявились. Выкладывать стоит после тестов, ревью и вашего решения.

Читайте также

Источники

  1. A01:2025 Broken Access Control (OWASP)
  2. Secrets Management Cheat Sheet (OWASP)
  3. Best practices for Claude Code (Anthropic)
  4. Common workflows (Anthropic)
  5. Custom instructions with AGENTS.md (OpenAI)
  6. Review GitHub pull requests with Codex (OpenAI)
  7. Application card: GitHub Copilot Agents (GitHub)
  8. Replit Agent (Replit)
  9. Checkpoints and Rollbacks (Replit)
  10. Write-Ahead Logging (SQLite)
  11. Set A Busy Timeout (SQLite)
  12. Software Engineering at Google, Chapter 9: Code Review (Google)
  13. Software Engineering at Google, Chapter 11: Testing Overview (Google)
  14. The Practical Test Pyramid (MartinFowler.com / Ham Vocke)
  15. PRAGMA busy_timeout (SQLite)
Консультация · 60 минут · 6 000 ₽Обсудить свою задачуОпишите задачу в Telegram-боте, разберём её на созвоне.