Эксперимент с автономным AI-разработчиком: как настроить workflow с генерацией тестов и исправлением багов

Код генерируется за секунды. Тесты и баги - за часы

Вы запускаете AI-агента. Через минуту у вас готовый модуль на 300 строк. Звучит идеально, пока не понимаешь: теперь этот код нужно проверить, покрыть тестами, отладить. И вот вы уже не разработчик, а надзиратель на конвейере, который не успевает за скоростью.

Я провел эксперимент: 2 часа, $22, и автономный цикл разработки, где AI сам пишет код, генерирует тесты, находит баги и исправляет их. Без моего участия. Результаты удивили даже меня.

Что такое автономный разработчик и почему это не просто кодогенератор

Автономный AI-разработчик - это не ChatGPT с промптом "напиши код". Это система, которая понимает контекст проекта, знает архитектуру, умеет запускать тесты, читать ошибки и вносить исправления. Как junior-разработчик, который никогда не устает и не просит повышения.

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

• Генерирует код по задаче
• Создает юнит-тесты для этого кода
• Запускает тесты и анализирует результаты
• Если тесты падают - анализирует ошибки
• Вносит исправления и повторяет цикл
• Документирует изменения

Звучит футуристично? Это уже работает. И дешевле, чем вы думаете.

Стек: что нужно для запуска

Я пробовал три подхода. Первый - локальные модели (Llama, DeepSeek). Второй - облачные API (GPT, Claude). Третий - гибрид. Вот что получилось:

Почему Verdant, а не LangChain или CrewAI? Verdant заточен под циклические workflow с обратной связью. Он умеет хранить состояние между итерациями, что критично для нашего цикла "код-тест-исправление".

1 Устанавливаем и настраиваем Verdant

Клонируем репозиторий и настраиваем окружение:

git clone https://github.com/verdant-ai/verdant.git
cd verdant
pip install -r requirements.txt

Создаем файл конфигурации config.yaml:

workflows:
  autonomous_dev:
    steps:
      - analyze_requirements
      - generate_code
      - create_tests
      - run_tests
      - analyze_failures
      - fix_code
      - document_changes

models:
  primary:
    provider: openai
    model: gpt-4o
    temperature: 0.2
    max_tokens: 4000
  
  fast:
    provider: openai
    model: gpt-3.5-turbo
    temperature: 0.1
    max_tokens: 2000

api_keys:
  openai: ${OPENAI_API_KEY}
  anthropic: ${ANTHROPIC_API_KEY}

2 Пишем workflow для автономной разработки

Вот скелет workflow в Verdant. Это не код Python, а декларативное описание процесса:

# autonomous_dev_workflow.yaml
name: Autonomous Developer Workflow
description: Полный цикл разработки с тестами и исправлением багов

trigger:
  type: webhook
  endpoint: /start-dev

states:
  initial:
    action: analyze_task
    parameters:
      task: "{{task_description}}"
      context_files: ["requirements.txt", "project_structure.json"]
    next: code_generation
  
  code_generation:
    action: generate_code
    model: primary
    parameters:
      task_summary: "{{previous.output}}"
      language: python
      style_guide: "pep8"
    next: test_creation
  
  test_creation:
    action: create_tests
    model: fast  # Для тестов хватит GPT-3.5
    parameters:
      code: "{{code_generation.output}}"
      test_framework: "pytest"
      coverage_target: 80
    next: test_execution
  
  test_execution:
    action: run_tests
    executor: local_docker  # Запускаем в изолированном контейнере
    parameters:
      code: "{{code_generation.output}}"
      tests: "{{test_creation.output}}"
    next: analyze_results
  
  analyze_results:
    action: analyze_test_results
    model: primary
    parameters:
      test_output: "{{test_execution.output}}"
      original_code: "{{code_generation.output}}"
    conditions:
      - if: "{{output.passed == false}}"
        next: fix_code
      - if: "{{output.passed == true}}"
        next: documentation
  
  fix_code:
    action: fix_bugs
    model: primary
    parameters:
      code: "{{code_generation.output}}"
      test_errors: "{{analyze_results.output.errors}}"
      max_iterations: 5  # Не даем зациклиться
    next: test_execution  # Возвращаемся к запуску тестов
  
  documentation:
    action: generate_docs
    model: fast
    parameters:
      final_code: "{{code_generation.output}}"
      test_results: "{{analyze_results.output}}"
    next: complete

Ключевой момент: максимум 5 итераций на исправление. Без этого ограничения AI может зациклиться на одной ошибке, сжигая ваш бюджет. (Спросите меня, откуда я это знаю.)

3 Промпты, которые действительно работают

90% успеха - в промптах. Вот те, что прошли боевое крещение:

Для генерации кода:

Ты - senior Python разработчик. Следуй строго этим правилам:
1. Код должен работать с Python 3.9+
2. Используй typing annotations для всех функций
3. Документация в формате Google docstrings
4. Обрабатывай edge cases: None, пустые списки, большие числа
5. Оптимизируй для читаемости, а не для краткости

Задача: {{task}}

Контекст проекта:
{{project_context}}

Существующие модули:
{{existing_modules}}

Начни с анализа требований, затем предложи архитектуру, затем напиши код.

Для генерации тестов:

Создай исчерпывающие тесты для этого кода. Включи:
1. Юнит-тесты для каждой функции
2. Тесты edge cases
3. Моки для внешних зависимостей
4. Параметризованные тесты где уместно
5. Проверку на корректность типов

Код для тестирования:
{{code}}

Используй pytest. Каждый тест должен иметь четкое имя, объясняющее что он проверяет.

Для анализа падающих тестов:

Проанализируй вывод тестов и найди корневую причину failures.

Код:
{{code}}

Тесты:
{{tests}}

Вывод тестов:
{{test_output}}

Предоставь:
1. Список падающих тестов
2. Причину каждой ошибки
3. Конкретные строки кода, которые нужно изменить
4. Рекомендации по исправлению

Будь конкретен. Не говори "возможно проблема в". Говори "ошибка в строке 42: функция не обрабатывает None".

Что получилось: цифры и инсайты

Эксперимент: разработать модуль для валидации конфигураций YAML с 15 правилами проверки.

• Время работы workflow: 2 часа 17 минут
• Затраты на API: $22.43 (GPT-4o для кода, GPT-3.5 для тестов)
• Сгенерировано кода: 420 строк Python
• Сгенерировано тестов: 18 тестов, 310 строк
• Итераций исправления: 7 (2 цикла зациклились, пришлось остановить)
• Итоговое покрытие: 87%

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

Где все ломается: 5 ошибок, которые сожгут ваш бюджет

1. Бесконечные циклы исправления

AI исправляет ошибку A, что ломает B. Исправляет B, что возвращает ошибку A. Цикл может длиться вечно. Решение: жесткое ограничение итераций (3-5) + эскалация человеку после.

2. "Галлюцинации" с импортами

AI генерирует код с несуществующими библиотеками или неправильными версиями API. Решение: включать в контекст точные версии зависимостей из requirements.txt.

3. Оптимизация под токены, а не под качество

Модель экономит токены, создавая краткий, но нечитаемый код. Решение: явно требовать читаемость и запрещать однобуквенные переменные.

4. Игнорирование архитектурных constraints

AI создает монолит, когда нужны микросервисы. Решение: давать явные архитектурные ограничения в промпте, как в статье про проектирование агентов.

5. Тесты, которые тестируют не то

AI генерирует тесты, которые проходят, но не проверяют критическую логику. Решение: требовать тесты для каждого требования из ТЗ явным списком.

Когда это работает, а когда - пустая трата денег

Работает:

• Генерация boilerplate кода (CRUD, API endpoints)
• Создание тестов для существующего кода
• Рефакторинг по четким правилам (переименование, разбиение функций)
• Нахождение edge cases и багов в спецификации
• Документирование сложных модулей

Не работает:

• Разработка с нуля без четких требований
• Задачи, требующие глубокого доменного знания
• Оптимизация производительности (AI будет гадать)
• Работа с легаси кодом, где нет документации
• Критически важные для безопасности модули

Что дальше: куда движется автономная разработка

Через 2 месяца экспериментов я вижу три тренда:

1. Гибридные модели - локальная маленькая модель для простых задач, облачная большая для сложных. Как в Speculative Decoding, но для workflow.
2. Специализированные агенты - не один автономный разработчик, а команда: архитектор, кодер, тестировщик, ревьюер. Как три мозга вместо одного, но для кода.
3. Предиктивный дебаггинг - AI не ждет падения тестов, а предсказывает где могут быть баги на основе паттернов.

Мой прогноз: через год автономные разработчики станут таким же стандартом, как CI/CD. Не для замены людей, а для устранения рутины. Разработчик будет проектировать систему, AI - воплощать ее в код и тесты, человек - проверять архитектуру и бизнес-логику.

Последний совет: начните с малого. Не пытайтесь автоматизировать всю разработку. Возьмите один тип задач - например, генерацию тестов или рефакторинг - и отточите workflow на нем. Потом масштабируйте.

И помните: лучший автономный разработчик - это не тот, который никогда не ошибается. Это тот, который умеет признавать ошибки и учиться на них. Почти как человек. Только дешевле и работает по ночам.