r3tam blog

Loop Engineering без Codex/Claude - как?

12 мин. чтения

Loop Engineering без Codex/Claude: Полный гайд по открытым инструментам

Введение

В середине 2026 года индустрия разработки переживает тектонический сдвиг. Борис Черни, создатель Claude Code в Anthropic, больше не пишет промпты вручную — он проектирует циклы, которые управляют агентами. Питер Штейнбергер, основатель OpenClaw, собрал 8 миллионов просмотров заявление: «Хватит промптить агентов — начните проектировать циклы». Этот подход получил название Loop Engineering, и он определяет 2026 год.

Проблема в том, что большинство материалов по Loop Engineering завязаны на проприетарные инструменты — Claude Code от Anthropic и OpenAI Codex. Они мощные, но дорогие, закрытые и привязывают вас к одному вендору. Что делать, если вы хотите строить циклы, но не хотите платить $20 в месяц за каждого разработчика или отдавать код на чужие сервера?

В этой статье я разберу, как заниматься Loop Engineering с открытым стеком. Вы узнаете, какие инструменты заменяют Claude Code и Codex, как подключить локальные модели, и увидите рабочие примеры циклов, которые можно запустить уже сегодня. Никаких проприетарных агентов — только open source и ваши собственные API-ключи.

Что такое Loop Engineering и почему он нужен каждому

Loop Engineering — это практика проектирования систем, которые автоматически управляют AI-агентами: ставят задачи, проверяют результаты и запускают следующие итерации. Человек больше не сидит в диалоговом окне, печатая «сделай то», «теперь это», «нет, переделай». Вместо этого он один раз описывает цель и условия завершения, а система делает всё остальное.

Архитектура цикла опирается на пять строительных блоков: автоматизации (триггеры по расписанию или событиям), worktree'ы (изолированные окружения для параллельных агентов), скиллы (проектные знания, которые агент загружает при старте), плагины и коннекторы (через Model Context Protocol) и суб-агенты (разделение на «писателя» и «проверяющего»). Шестой элемент — память, чтобы цикл не забывал, что уже сделано.

Почему это важно? Потому что ручное промптинг не масштабируется. Один разработчик может вести один диалог с агентом. Цикл может управлять десятками задач параллельно, перезапускать упавшие шаги, логировать прогресс и останавливаться, когда цель достигнута. Это не будущее — это настоящее. Claude Code уже имеет встроенную команду /goal, Codex — Automations и Worktrees. Вопрос только в том, как получить те же возможности без привязки к вендору.

Открытая экосистема: кто заменяет Claude Code и Codex

Рынок open-source AI-инструментов для кодинга взорвался в 2025–2026 годах. Если в 2024 году выбор ограничивался Aider и экспериментальным Continue.dev, то сейчас существует как минимум пять зрелых альтернатив, способных работать в цикле.

OpenCode — главный открытый конкурент Claude Code

OpenCode набрал более 170 тысяч звёзд на GitHub и обогнал Claude Code по популярности среди open-source решений. Это терминальный TUI-агент, который работает с любым редактором и поддерживает более 75 провайдеров моделей — от OpenAI и Anthropic до локальных Ollama-инстанций. OpenCode имеет встроенную систему скиллов (через SKILL.md), поддержку MCP-серверов и worktree'и для параллельной работы.

Главное преимущество OpenCode — модель лицензирования. Это MIT-лицензия, полный контроль над данными и возможность переключить модель одной командой. Вы платите только за токены API или используете локальную модель бесплатно.

# Установка OpenCode
npm install -g opencode

# Запуск с локальной моделью
opencode --model ollama/deepseek-coder-v2

# Запуск цикла через opencode run
opencode run --task "Добавить тесты для модуля auth" --goal "coverage > 80%"

Aider — ветеран с git-интеграцией

Aider существует дольше всех и остаётся лучшим выбором для тех, кто хочет минималистичный терминальный интерфейс с прозрачной работой через git. Aider автоматически создаёт коммиты, поддерживает map-файлы репозитория для эффективного контекста и умеет работать с любой OpenAI-совместимой API.

Особенность Aider — архитектура «архитектор + редактор»: одна модель планирует изменения, другая — реализует. Это встроенный паттерн суб-агентов, который в Claude Code и Codex появился только в 2026 году.

# Aider с Claude через API
aider --model anthropic/claude-opus-4-20260416

# Aider с локальной моделью
aider --model ollama/deepseek-coder-v2

# Режим архитектор + редактор (автоматически)
aider --architect --model architect-model --editor editor-model

Gemini CLI — самый щедрый free-tier

Google выпустила Gemini CLI с постоянным бесплатным тарифом — 1000 запросов в день. Это не триал, это навсегда. Gemini CLI поддерживает голосовой режим, офлайн-поиск через ripgrep, MCP-серверы и локальные модели Gemma 4. Код полностью открыт под лицензией Apache 2.0.

Минус — только Gemini-модели, никакого Claude или GPT. Но для 80% повседневных задач Gemini 3.1 Pro более чем достаточен, а 1000 бесплатных запросов в день покрывают потребности небольшой команды.

# Установка Gemini CLI
curl -fsSL https://cli.gemini.google.com/install.sh | bash

# Запуск задачи
gemini run "Рефакторинг модуля payments"

# Режим цикла с целью
gemini run --goal "all tests pass" --iterations 10

Cline и Roo Code — VS Code-агенты

Если вы не готовы уходить из IDE, Cline (63k звёзд, Apache 2.0) и Roo Code (19k звёзд, MIT) предоставляют agentic-режим прямо в VS Code. Они умеют читать файлы, писать код, запускать терминал и создавать коммиты — всё, что делает Claude Code, но внутри редактора и с любой моделью.

Cline особенно хорош для пошагового планирования: он показывает каждый шаг перед выполнением и запрашивает подтверждение. Это снижает риск «галлюцинаций» и даёт полный контроль над процессом.

Как построить цикл без Codex и Claude: практическое руководство

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

Сценарий 1: Ежедневная триажная задача

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

#!/bin/bash
# daily-triage-loop.sh

REPO_PATH="/path/to/repo"
LOOP_LOG="$REPO_PATH/.loop/daily-triage.log"

# Шаг 1: Получить список открытых issue
gh issue list --state open --json number,title,labels --limit 20 > /tmp/issues.json

# Шаг 2: Запустить агента для категоризации
opencode run \
  --input /tmp/issues.json \
  --task "Классифицировать issue по категориям: bug, feature, docs, question.
          Для каждой issue предложить исполнителя на основе истории." \
  --output /tmp/triage-result.md \
  --model ollama/llama-3.3-70b

# Шаг 3: Применить результат
while IFS= read -r line; do
  ISSUE_NUM=$(echo "$line" | cut -d'|' -f1)
  LABEL=$(echo "$line" | cut -d'|' -f2)
  ASSIGNEE=$(echo "$line" | cut -d'|' -f3)
  gh issue edit "$ISSUE_NUM" --add-label "$LABEL" --add-assignee "$ASSIGNEE"
done < /tmp/triage-result.md

# Шаг 4: Записать в лог
echo "[$(date)] Триаж завершён. Обработано $(wc -l < /tmp/triage-result.md) issue." >> "$LOOP_LOG"

Запускать такой скрипт можно через cron (Linux/macOS) или systemd-таймер. Никаких Claude Code или Codex — только OpenCode и GitHub CLI.

Сценарий 2: Цикл «напиши и проверь»

Классический паттерн разработки: агент пишет код, затем второй агент его проверяет. Это встроенный maker-checker pattern, который рекомендуют и Anthropic, и OpenAI.

#!/bin/bash
# maker-checker-loop.sh

TASK="$1"
GOAL="All tests pass, lint passes, typecheck passes"

while true; do
  # Фаза 1: Писатель
  opencode run --task "$TASK" --output /tmp/writer-output
  
  # Фаза 2: Проверяющий (другая модель)
  opencode run \
    --task "Проверить изменения в репозитории.
            Критерии:
            - Все существующие тесты проходят
            - Линтер не выдаёт ошибок
            - Типчекер проходит
            - Нет dead code
            Если проблемы есть — исправь их." \
    --model ollama/deepseek-coder-v2
  
  # Фаза 3: Проверка условия завершения
  if npm test && npm run lint && npm run typecheck; then
    echo "Цель достигнута!"
    break
  fi
  
  # Фаза 4: Анализ ошибок и повтор
  ERROR_LOG=$(npm test 2>&1 | tail -50)
  TASK="Исправить ошибки в тестах: $ERROR_LOG"
  
  # Предотвращение бесконечного цикла
  ITERATIONS=$((ITERATIONS + 1))
  if [ "$ITERATIONS" -gt 5 ]; then
    echo "Превышен лимит итераций. Остановка."
    exit 1
  fi
done

Сценарий 3: Ночной рефакторинг

Самый мощный сценарий — цикл, который работает, пока вы спите. Он находит участки кода для улучшения, рефакторит их, проверяет и создаёт pull request.

Сначала создадим конфигурационный файл .loop/config.yaml:

# .loop/config.yaml
trigger:
  schedule: "0 2 * * *"  # Каждую ночь в 2:00
  # Альтернатива: trigger on push to main

goal:
  description: "Уменьшить сложность кода. McCabe complexity < 10 для всех функций."
  verification:
    - command: "npx eslint --max-warnings 0"
    - command: "npx ts-prune"
    - command: "npm test"

skills:
  - name: code-style
    file: .loop/skills/code-style.md
  - name: project-context
    file: .loop/skills/project-context.md

limits:
  max_iterations: 10
  max_cost: 5.00  # $5 за ночь
  timeout_minutes: 60

Теперь сам скрипт запуска:

#!/bin/bash
# nightly-refactor-loop.sh

cd /path/to/repo

# Создать ветку для рефакторинга
BRANCH="refactor/loop-$(date +%Y%m%d)"
git checkout -b "$BRANCH"

# Запустить OpenCode в режиме цикла
opencode run \
  --skill .loop/skills/code-style.md \
  --task "Найти функции со сложностью McCabe > 10 и отрефакторить их.
          Использовать skills из .loop/skills/.
          Проверять после каждого изменения: eslint, ts-prune, тесты." \
  --goal "npx eslint --max-warnings 0 && npm test" \
  --max-iterations 10 \
  --model claude-sonnet-4-20260515

# Если цикл завершился успешно — создать PR
if [ $? -eq 0 ]; then
  git add -A
  git commit -m "refactor: nightly loop refactoring $(date +%Y-%m-%d)"
  git push origin "$BRANCH"
  gh pr create \
    --title "Nightly refactoring $(date +%Y-%m-%d)" \
    --body "Автоматический рефакторинг. Уменьшение сложности кода." \
    --label refactoring
fi

Локальные модели: Loop Engineering без единого API-запроса

Самый радикальный сценарий — полный отказ от облачных API. Вы запускаете модели локально через Ollama или LM Studio и строите циклы, которые не покидают вашу машину. Это критично для команд с жёсткими требованиями к безопасности данных.

Какие модели подходят для циклов:

  • DeepSeek Coder V2 (16B) — отличный баланс качества и производительности, работает на 16 GB VRAM. Лучший выбор для code review внутри цикла.
  • Llama 3.3 70B (Q4) — требует 40 GB VRAM, но даёт качество, близкое к GPT-4. Подходит для архитектурных решений в цикле.
  • Phi-4 Reasoning (14B) — работает на 8–16 GB VRAM. Microsoft доказала, что маленькие модели могут рассуждать на уровне больших. Идеально для фазы верификации.
  • Qwen 2.5 Coder (32B) — сильный конкурент DeepSeek, особенно хорош в генерации кода на Python и TypeScript.
# Пример цикла с полностью локальной моделью
opencode run \
  --model ollama/qwen-2.5-coder:32b \
  --task "Реализовать REST API для модуля users" \
  --goal "npm test && npm run lint" \
  --local-only  # Запретить любые внешние запросы

Эти модели не уступают проприетарным в 80% повседневных задач. Они медленнее, но для ночных циклов скорость не имеет значения.

MCP и плагины: соединяем инструменты без вендор-лока

Model Context Protocol (MCP) — это открытый стандарт, который позволяет агентам подключаться к внешним инструментам: базам данных, API, файловой системе. И Claude Code, и OpenCode, и Gemini CLI поддерживают MCP.

Собирая цикл из открытых компонентов, вы можете подключить:

  • MCP сервер для Jira — агент создаёт и перемещает задачи
  • MCP сервер для Sentry — агент анализирует ошибки и предлагает фиксы
  • MCP сервер для PostgreSQL — агент выполняет миграции и проверяет схемы
  • MCP сервер для Slack — агент отправляет уведомления о статусе цикла
// .mcp/config.json
{
  "servers": {
    "jira": {
      "command": "npx",
      "args": ["@mcp/jira", "--token", "${JIRA_TOKEN}"],
      "env": {
        "JIRA_URL": "https://company.atlassian.net"
      }
    },
    "sentry": {
      "command": "npx",
      "args": ["@mcp/sentry", "--token", "${SENTRY_TOKEN}"]
    },
    "postgres": {
      "command": "npx",
      "args": ["@mcp/postgres", "--connection-string", "${DB_URL}"]
    }
  }
}

Никакой привязки к конкретному агенту — конфигурация работает с любым MCP-совместимым инструментом.

Подводные камни и как их избежать

Loop Engineering — мощный подход, но у него есть тёмная сторона. Вот главные проблемы, с которыми вы столкнётесь:

Бесконечные циклы и утечка токенов. Самая частая проблема — цикл не может достичь цели и продолжает итерации, сжигая токены. Решение — всегда устанавливать жёсткие лимиты: максимальное количество итераций, бюджет в долларах и timeout.

Галлюцинации прогресса. Агент сообщает, что тесты проходят, хотя на самом деле он их не запускал. Единственное лекарство — верификация через реальные команды (npm test, а не «скажи, всё ли ок»).

Конфликты при параллельной работе. Несколько агентов, редактирующих одни и те же файлы, создают конфликты. Worktree'и (изолированные копии файловой системы) решают эту проблему — каждый агент работает в своём sandbox.

Loopmaxxing. Термин 2026 года для ситуации, когда разработчик тратит больше времени на проектирование цикла, чем сэкономил на автоматизации. Правило простое: если задача занимает меньше пяти минут вручную — не пишите под неё цикл.

Заключение

Loop Engineering — это не очередной хайповый термин, а закономерная эволюция работы с AI-агентами. Сдвиг от «я промпчу агента» к «я проектирую систему, которая промптит агента» меняет роли в разработке. Инженер превращается из оператора в архитектора.

Хорошая новость в том, что для этого сдвига не нужны проприетарные инструменты. OpenCode, Aider, Gemini CLI и локальные модели дают тот же уровень контроля над циклами, что и Claude Code с Codex, — без вендор-лока и с полной прозрачностью данных. MCP-стандарт делает экосистему совместимой: вы не привязаны к одному агенту.

Начните с малого. Возьмите одну рутинную задачу — триаж issue, ночной рефакторинг, проверку PR — и постройте для неё цикл на OpenCode или Aider. Установите лимиты, добавьте верификацию и запустите под cron. Через неделю вы увидите, сколько времени освободилось для настоящей инженерной работы.

А когда цикл отработает первую ночь без сбоев, вы поймёте, почему Борис Черни больше не промптит Claude вручную.

FAQ

Чем Loop Engineering отличается от простого bash-скрипта с вызовом API?

Цикл — это не просто последовательность вызовов API. Он включает верификацию результата, адаптивную коррекцию на основе обратной связи и условие завершения. Bash-скрипт линейный, цикл — рекурсивный.

Можно ли комбинировать разные модели в одном цикле?

Да, это стандартная практика. Дешёвая модель (например, DeepSeek Coder) пишет код, дорогая (Claude или GPT через API) проверяет архитектуру. OpenCode и Aider поддерживают разные модели для разных ролей.

Сколько стоит запуск цикла с локальными моделями?

Только электричество и амортизация GPU. Для Llama 3.3 70B (Q4) нужно ~40 GB VRAM — это одна consumer-карта уровня RTX 5090. Phi-4 работает на 8 GB — встраивается в любой современный ноутбук.

Как остановить цикл, если что-то пошло не так?

Всегда устанавливайте max_iterations, timeout и max_cost. Добавьте сигнал остановки через файл: touch .loop/stop. Агент проверяет наличие этого файла перед каждой итерацией.

Какой инструмент выбрать новичку в Loop Engineering?

Начните с OpenCode — у него самое большое сообщество, лучшая документация и интерактивный pattern picker на сайте. Когда освоитесь, добавьте Aider для git-центричных циклов и Gemini CLI для задач с бесплатным лимитом запросов.