Финал серии: Agent Teams, GitHub Actions, Agent SDK, TDD, Ralph-loop на ночь и осторожный прогноз на 2027

Серия на Хабре: часть 1 - что Claude Code умеет из коробки · часть 2 - настройки, хуки и Context Rot · часть 3 - автономная работа и параллелизм.

Однажды вечером я дал Claude Code не задачу "сделай фичу", а уже написанную спеку и сложный план. Дальше работал не один чат, а цепочка: оркестратор разобрал план на независимые куски, поднял кодеров в отдельных worktree, дождался их diff'ов, потом вызвал ревьюеров на каждый кусок и собрал итоговый отчёт. Утром у меня был не "ответ ассистента", а несколько веток, замечания ревью и список решений, которые всё равно должен принять человек.

Это третья и финальная часть серии. В первой я показал что такое Claude Code и почему я называю его командой из 15. Во второй - десять настроек, которые эту команду делают управляемой: CLAUDE.md на 30 строк, permissions, хуки, совещание ботиков через Codex и Gemini, Context Rot.

Сегодня про следующий уровень. Когда конфиги настроены и работаешь каждый день, упираешься в новый потолок. Даже команда из 15 человек внутри одной сессии Claude имеет предел. Субагенты конкурируют за контекст, ветки мешают друг другу, ты переключаешься между задачами и теряешь состояние.

Дальше начинается параллелизм, автоматизация и автономия. Десять приёмов, которые превращают Claude Code из "умного помощника" в систему из отдельных агентов, scheduled tasks и CI-задач.

И в конце - честный разговор про то, куда всё это идёт в 2027 и что останется разработчику.

1. Собственные субагенты в .claude/agents/

Субагенты - это отдельные "профили" Claude с ограниченным набором инструментов, своей моделью и своим системным промптом. Каждый субагент работает в своём контекстном окне и возвращает в основную сессию только итог. Главный Claude оркестрирует, субагенты выполняют специализированные задачи.

Встроенные в комплекте идут Explore, Plan и general-purpose. Explore нужен для поиска и анализа без правок, Plan - для исследования в plan mode, general-purpose - для обычных делегированных задач. Но настоящая сила в кастомных.

Главное не перепутать субагента с коротким role prompt. Нормальный агент - это не 15 строк "ты опытный ревьюер". Это markdown-спека: личность, зона ответственности, входные данные, правила калибровки, формат результата, стоп-критерии, анти-паттерны. Frontmatter только говорит Claude Code как этого агента запускать.

Условный файл .claude/agents/seeker.md. Сначала служебная шапка:

---
name: seeker
description: Finds evidence-backed niche opportunities from a founder profile
tools: Read, Grep, Glob, WebFetch
model: opus
permissionMode: plan
maxTurns: 40
effort: high
color: cyan
---

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

# Agent: SEEKER
## Version: 4.1 - profile-aware + outcome-driven search

> Canonical: this file is source of truth.
> Mission anchor: Everyone has a niche. We help you find yours and build it.

---

## Who You Are

You are Seeker. You find real niches - places where someone's already
paying for a bad solution, quietly. You aren't here to impress. You're
here to notice what others walked past.

You work in tandem with Destroyer. Shared metric: the user ships something
that reaches meaningful revenue within 12 months. If you pick mush,
you both lose.

Character anchor: the scout who finds real places most people walked past.
Curious, specific, allergic to hype.

---

## The Product You're Part Of

Foundry is an AI that finds users their niche and helps them build it.
You are step one of a six-step pipeline.

1. Seeker - find 3 candidate niches with evidence
2. Destroyer - stress-test each niche
3. Plan - convert chosen niche to business plan
4. Brand - name it, set voice
5. Marketing -> Landing -> MVP -> Launch

Downstream agents read your output from the database. Thin fields break
downstream silently. Specificity you commit to here saves three agents later.

...

## Input You Receive
## Revenue Calibration
## Scope - What Counts as a Niche
## WebSearch Protocol
## Output Contract
## Rejection Rules

Вот это уже похоже на агента. Он не просто "думает как исследователь", он знает свой участок конвейера, кто читает его результат дальше, какие поля нельзя заполнять тонко, где стоп-критерий поиска, какие идеи надо отбрасывать. Чем автономнее агент, тем меньше он должен быть похож на подсказку из ChatGPT.

Что важно в frontmatter: tools: Read, Grep, Glob лишает агента возможности писать файлы или запускать команды. Даже если промпт скажет "исправь найденное" - не сможет. permissionMode: plan дополнительно держит его в read-only режиме. model: opus и effort: high ставлю для глубокого анализа; для test-writer обычно хватает Sonnet.

Вызов из основной сессии: @seeker analyze this founder profile and return 3 evidence-backed niches. Главный Claude делегирует, получает отчёт, продолжает. Можно запускать несколько субагентов параллельно и агрегировать результаты.

Если агент должен не только читать, но и писать код, я почти всегда добавляю isolation: worktree. Тогда каждый запуск получает отдельную копию репозитория и не пачкает основную рабочую директорию. Это опять же только шапка, а не весь агент:

---
name: refactor-specialist
description: Multi-file refactoring in an isolated branch
tools: Read, Grep, Glob, Edit, Write, Bash
model: opus
permissionMode: acceptEdits
isolation: worktree
background: true
---

# Refactor Specialist

## Mission
Refactor only the assigned module in an isolated worktree.

## Operating Rules
## Search Protocol
## Implementation Contract
## Test Requirements
## Review Handoff

... full refactoring playbook goes here ...

Когда НЕ делать субагента: если задача одноразовая. Если всё делается одним промптом на 3-5 строк - это промпт, не субагент. Субагенты нужны когда роль повторяется в десятках сессий.

2. Agent Teams: оркестратор, кодеры и ревьюеры

Agent Teams требуют Claude Code v2.1.32 или новее и пока экспериментальные. Включаются env-переменной:

export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

После этого можно координировать несколько Claude Code-сессий как команду: один lead-agent держит общий план, teammates идут в своих контекстах, общаются между собой и возвращают результат наверх. Это уже не обычные subagents внутри одной сессии, а отдельные сессии под общей задачей.

Типовой кейс, где это имеет смысл: крупный multi-file рефакторинг, когда у тебя уже есть спека и утверждённый план. Не "пойди подумай что-нибудь", а нормальный документ: цель, инварианты, какие модули можно трогать, какие нельзя, критерий готовности, rollback. Тогда Agent Teams работают не как болталка агентов, а как маленькая инженерная смена:

Оркестратор читает спеку и план, режет работу на независимые юниты
Каждый юнит получает кодер-агент со своей полной инструкцией, а не коротким "напиши код"
Кодеры работают в отдельных worktree и возвращают diff, тесты, риски и что не трогали
Оркестратор вызывает ревьюеров на готовые diff'ы: security, tests, architecture или domain-specific
После ревью оркестратор собирает итог: что мержить, что переделать, где нужен ручной выбор

На практике качество здесь держится не на "много агентов", а на хороших agent specs. Кодер без правил проекта будет красиво ломать архитектуру. Ревьюер без чеклиста будет писать общие замечания. Оркестратор без exit criteria будет гонять команду по кругу.

Точную цифру ускорения без своей телеметрии я бы не обещал. Сами Anthropic в документации пишут про coordination overhead и повышенный расход токенов. Выигрыш есть только когда юниты реально независимы. Если пять агентов правят один и тот же модуль, ты получишь не "ускорение", а пять вариантов конфликта.

Работает в паре с git worktrees, про которые дальше.

3. Git worktrees: параллельные ветки без общей рабочей директории

Git worktree - это отдельная копия рабочего дерева репозитория, привязанная к своей ветке. У тебя несколько физически изолированных папок с одной git-историей. В Claude Code это вынесли в отдельный флаг --worktree, чтобы не собирать всё руками.

# Main project in ~/work/myapp on main
cd ~/work/myapp

# Start Claude in an isolated worktree for feature A
claude --worktree feature-a

# Start another isolated worktree for bugfix B
claude --worktree bugfix-b

# Manual git worktree still works if you need full control
git worktree add ../myapp-hotfix hotfix/session-timeout
cd ../myapp-hotfix && claude

Два экземпляра Claude пишут код в разных ветках одновременно и не дерутся за одну рабочую директорию. Это не отменяет merge conflict при финальном слиянии, если оба всё-таки поменяли одни и те же строки. Но главный хаос параллельной работы исчезает: у каждой сессии свой checkout, свой diff, своя ветка.

Связка с /batch: команда /batch migrate src/ from Solid to React под капотом декомпозирует задачу на 5-30 независимых юнитов, поднимает background agent в отдельном git worktree на каждый юнит, прогоняет тесты и собирает PR в конце.

Что я бы не делал: не публиковал истории "47 файлов за 8 часов" без ссылки на исходный кейс. Для своей команды лучше считать скучно: сколько юнитов было создано, сколько PR прошло тесты с первого раза, сколько конфликтов пришлось руками разруливать.

Мелочь, которая ломает ночные запуски: worktree - чистый checkout. Gitignored-файлы вроде .env.local, локальных сертификатов и dev-конфигов туда сами не попадут. Для этого есть .worktreeinclude:

.env.local
config/dev.json
certs/local/*.pem

Синтаксис как у .gitignore: Claude скопирует совпадающие файлы в новый worktree, если они уже игнорируются git. Секреты всё равно не коммитятся, но агент не падает через минуту с "missing config".

Уборка: git worktree remove ../myapp-feature-a когда ветка слита.

4. Headless mode и /schedule: Claude как обычный CLI

Claude Code прекрасно работает в терминале интерактивно. Но через claude -p он превращается в обычную CLI-утилиту для bash-скриптов. В документации это уже описывается как programmatic usage через Agent SDK CLI; раньше чаще говорили "headless mode".

# One-shot: pass a prompt, get a response, exit
claude -p "Analyze git log for the last week and write a weekly report into CHANGELOG.md"

# Bare mode for CI: skip auto-discovery of hooks, skills, MCP, memory and CLAUDE.md
claude -p "Check whether package.json has vulnerable dependencies" --bare

# JSON output for parsing
claude -p "Summarize this project" --output-format json | jq -r '.result'

Exit codes честные: 0 если всё ок, non-zero при ошибке. Можно встраивать в любой shell-пайплайн. Я использую для ежедневных отчётов:

#!/usr/bin/env bash
# ~/.scripts/daily-standup.sh
CHANGES=$(git log --since="yesterday" --oneline)
claude -p "I am the CTO. Write a short standup from these commits:
$CHANGES

Format:
- Done
- In progress
- Blockers

Be brief. No filler."

Бонусный приём - /loop и /schedule. Разница важная: /loop живёт в текущей сессии, cloud/desktop scheduled tasks переживают закрытый терминал.

/loop 20m check whether CI passed and address review comments

/schedule every Monday at 9am:
review stale pull requests, summarize blockers, and draft triage comments

У cloud tasks другой trade-off: они работают на Anthropic-managed инфраструктуре и не требуют включённого ноутбука, но не видят твои локальные файлы. Для локального состояния нужны Desktop scheduled tasks или обычный /loop в живой сессии.

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

5. GitHub Actions: Claude в пайплайне

Anthropic выкатила официальный GitHub Action anthropics/claude-code-action@v1. В одной workflow-ячейке ты получаешь Claude с доступом к коду репозитория, PR, issues и тестам, если выдал нужные permissions. Сам workflow остаётся обычным GitHub Actions YAML.

Минимальный конфиг для авто-ревью пулл-реквестов:

# .github/workflows/claude-review.yml
name: Claude Review
on:
  pull_request:
    types: [opened, synchronize]
  issue_comment:
    types: [created]

jobs:
  review:
    if: github.event_name == 'pull_request' ||
        contains(github.event.comment.body, '@claude')
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
      issues: write
    steps:
      - uses: actions/checkout@v4
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: |
            Review the PR focusing on:
            - Security issues
            - Obvious bugs
            - Missing tests for new logic
            Post findings as PR review comments.
          claude_args: "--max-turns 10"

С таким workflow каждый новый PR получает автоматическое ревью. Написал @claude fix lint errors в комменте - Claude может ответить в PR и внести правки, если workflow и GitHub App настроены с правами на запись.

Популярные паттерны из комьюнити:

Issue -> PR: тегаешь Claude в issue, он анализирует, создаёт ветку, пишет код, открывает PR
Ночная генерация тестов: workflow по cron проходит по файлам без покрытия, пишет тесты, открывает draft-PR
Release notes: на каждый тег генерится человеческий changelog из коммитов
Security-sweep: еженедельный проход по всему репозиторию на секреты и типовые уязвимости

Про деньги лучше не гадать. В v1 конфиге есть claude_args, туда можно положить --max-turns, модель и tool limits. После недели прогонов смотришь реальный usage, а не красивые цифры из чужого треда.

6. Agent SDK: Claude Code из Python и TypeScript

Если нужно встроить Claude во внутренний инструмент - бот в Slack, админку, monitoring dashboard - есть Claude Agent SDK. Это программная обёртка над тем же agent loop: Claude может читать файлы, запускать команды, править код, работать с tools и subagents.

pip install claude-agent-sdk
npm install @anthropic-ai/claude-agent-sdk

Базовый пример на Python:

import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions


async def main():
    options = ClaudeAgentOptions(
        allowed_tools=["Read", "WebFetch"],
        cwd="./support-docs",
        max_turns=10,
    )

    prompt = (
        "Customer reports: API returns 500 on POST /orders "
        "when the body has nested items. Check our docs and "
        "recent GitHub issues. Propose a hypothesis and the "
        "first file to inspect."
    )

    async for message in query(prompt=prompt, options=options):
        print(message)


asyncio.run(main())

SDK даёт то же что Claude Code в терминале, только вызываемое программно. Можно запускать из cron-задач, FastAPI-эндпоинтов, Slack-ботов. Работает и программное определение субагентов - не через файлы в .claude/agents/, а прямо в коде.

Типовой use-case: саппорт-триаж. Агент читает тикет, ищет в базе знаний, предлагает ответ или эскалирует. Но точные проценты автоматического закрытия я бы оставлял только если есть публичный кейс или свои логи.

TypeScript-версия работает аналогично, пакет @anthropic-ai/claude-agent-sdk. Для Node-бэкендов это часто проще чем Python.

7. Multi-file рефакторинг: Explore -> Plan -> Implement -> Commit

Это рекомендованный Anthropic workflow для изменений, где легко решить не ту задачу: сначала исследование, потом план, потом код. Не прокинуть всё в один промпт, а разбить на четыре фазы и между ними остановиться.

Главное здесь - Plan Mode между Explore и Implement. Без него Claude начинает править первый найденный файл, потом второй, и на пятом файле оказывается что в третьем нужно было другое решение. Плана нет - откатываться дороже чем начать заново.

Переключение между фазами: /plan для входа в Plan Mode, потом approve плана или Shift+Tab обратно в default/acceptEdits для реализации. Команды /code в актуальном command reference нет.

Если хочется не собирать этот процесс руками, посмотри Get Shit Done. Это open-source система для spec-driven development поверх Claude Code и других CLI-агентов. Она формализует тот же цикл: обсудить фазу, превратить её в план, выполнить план волнами, проверить результат и только потом ship. Самое полезное там не название и не магия промптов, а дисциплина: свежий контекст на каждую задачу, атомарные коммиты, выполнение независимых планов параллельными волнами, отдельный verify-шаг после реализации.

Для legacy-кода отдельный паттерн - Strangler Fig. Старый модуль не трогаешь. Вокруг него пишешь новый, перенаправляешь вызовы. Старое отмирает само, без большого взрыва. Claude отлично с этим справляется, если явно указать: "Don't modify legacy_auth.py. Create new auth/ module alongside. Migrate callers one at a time."

Чеклист перед рефакторингом на 10+ файлов. Есть ли тесты покрывающие целевое поведение? Если нет - сначала характеризационные тесты. Есть ли feature-флаг если что-то пойдёт не так? Worktree на отдельной ветке - да. Rollback-план очевиден. Только теперь /batch.

8. TDD на автопилоте: разделённые фазы и характеризационные тесты

Claude Code поддерживает TDD, но не так как большинство думает. Главная ошибка - дать один промпт "write function X with tests". В таком режиме Claude пишет тесты под свою имплементацию, и они все проходят с первого раза. Это не TDD, это красиво упакованный монолит.

Правильно - разделять фазы на отдельные промпты:

# 1. RED: tests only, no implementation
Write failing tests for a function validateEmail().
Requirements:
- user@example.com -> valid
- invalid -> invalid
- user@.com -> invalid (trailing dot)
- user name@example.com -> invalid (space)
Do NOT write the implementation. Tests must fail.

# 2. GREEN: minimal implementation
Now implement validateEmail() so tests pass.
Do the minimum to pass tests. No extra logic.

# 3. REFACTOR: improve readability
Refactor the implementation for readability.
Tests must keep passing.

Между фазами ты смотришь результат и корректируешь. Claude дисциплинируется по одной фазе и не скатывается в "напишу всё сразу".

Второй приём, важнее первого - характеризационные тесты перед рефакторингом legacy. Если код старый, тестов нет, а трогать надо - сначала пишешь тесты, которые фиксируют текущее поведение. Не желаемое, а текущее. Даже если оно неправильное.

Write characterization tests for legacy module src/payments/process.js.
DO NOT fix any bugs. Your job is to document current behavior,
including edge cases that look wrong. These tests must pass
against the current code as-is.

Осторожно с красивыми процентами. В бенчмарке Diffblue от 24 марта 2026 их Testing Agent на 8 Java-проектах дал 81% line coverage и 61% mutation coverage, а senior-разработчик с Claude Code за два часа - 32% и 24%. Это не значит что "Claude всегда пишет плохие тесты". Это значит что тесты без orchestration, проверки и чистки быстро упираются в потолок.

Хуки для автоматического прогона после Edit я показывал во второй части. Добавь к PostToolUse хук который запускает pytest tests/affected.py -x на основе изменённых файлов - и Claude получит короткий feedback loop вместо ручной проверки через полчаса.

9. Техника Ralph: while-loop, который пишет код пока ты спишь

Приём назван в честь Ralph Wiggum из "Симпсонов" - персонажа который просто продолжает делать одно и то же пока не получится. Суть: Claude Code в бесконечном цикле, пока задача не считается готовой. Каждая итерация запускает новую сессию, работает до завершения или ошибки, проверяет критерий готовности. Не готово - перезапуск с сохранённым контекстом.

#!/usr/bin/env bash
# ralph-loop.sh - autonomous Claude loop
set -e

TASK="$1"                    # task description
CHECK_CMD="$2"               # readiness check command (exit 0 = done)
MAX_ITER=50
ITER=0

while [ $ITER -lt $MAX_ITER ]; do
  ITER=$((ITER + 1))
  echo "===== Ralph iteration $ITER ====="

  claude -p "Task: $TASK
  This is iteration $ITER of $MAX_ITER.
  Read .ralph/state.md for previous attempts.
  Take the next concrete step toward completion.
  At the end, update .ralph/state.md with:
  - what changed
  - what remains
  - what is failing
  - next recommended command."

  if $CHECK_CMD; then
    echo "DONE at iteration $ITER"
    exit 0
  fi

  echo "Check failed, continuing..."
  sleep 10
done

echo "Max iterations reached. Manual intervention needed."
exit 1

Критерий готовности $CHECK_CMD - любая команда возвращающая 0 когда всё ок. Тесты прошли, билд собрался, lint чистый.

Два field report, которые полезно читать без фанатизма:

Geoffrey Huntley описывает Ralph как простой bash-loop: снова и снова отдавать агенту один prompt, пока проект не сойдётся. В его разборе Ralph используется для сборки нового языка программирования CURSED: компилятор, stdlib, runtime, tooling. Важная оговорка от самого Huntley: он не советует тащить этот подход в существующую production-кодовую базу без жёсткой верификации.

Есть и field report с YC Agents hackathon: команда RepoMirror прогоняла Claude Code в loop ночью и утром получила 1 000+ коммитов, несколько портированных кодовых баз и счёт меньше $800 на inference. Не магия. Просто очень длинный цикл с простым prompt и внешней проверкой.

Предупреждение. Ralph работает только если $CHECK_CMD честный. Если критерий готовности - "проходят ли тесты", а Claude имеет право эти тесты править - он зациклится на подгонке тестов под код. Критерий должен быть вне-контекстным: компиляция, внешний валидатор, скриншот-тест против эталона.

10. Что дальше: KAIROS, autoDream и 2027

Возвращаемся к утечке исходников Claude Code, с которой началась вся серия. Помимо KAIROS, в leaked source analysis нашли ещё два интересных куска. Ниже - не анонсы Anthropic, а выводы из разбора leaked-кода.

autoDream - предполагаемая функция консолидации памяти между сессиями. По leak-разбору, она должна проходить по дампам памяти, убирать противоречия, объединять дублирующиеся наблюдения и превращать размытые "кажется тут был баг" в конкретные факты. Anthropic это не подтверждала, поэтому публиковать как будущую официальную фичу нельзя.

Ultraplan уже частично материализовался официально: research preview в Claude Code v2.1.91+. Он отправляет планирование из CLI в Claude Code on the web, показывает план в браузере, даёт комментировать отдельные секции и потом выбрать где исполнять - в cloud-сессии или обратно в терминале.

Все три фичи - KAIROS, autoDream, ULTRAPLAN - складываются в одну картину: Claude Code к 2027 перестанет быть инструментом, который ты запускаешь. Он станет фоновым процессом, который работает всегда. Консолидирует знания о твоих проектах между сессиями. Планирует дальше в облаке пока ты обедаешь. Утром отдаёт готовые PR на утверждение.

Что это значит для разработчика? Не замену. Сдвиг.

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

Я начинал с AI на GPT-3.5, когда это было смешно. Видел всю эволюцию. Сейчас мы в моменте где AI делает работу среднего разработчика быстрее и лучше. К 2027 он будет делать её автономно. Остаётся вопрос: что значит быть разработчиком в мире где код - не узкое место?

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

Итог серии

Три статьи, тридцать приёмов, одна мысль. Человек стал узким местом разработки. Не инструменты, не лимиты, не модели. Сам человек, его внимание, его способность удерживать контекст и принимать решения.

Первая часть показала что Claude Code - это не автокомплит, а коллега. Вторая - как этого коллегу правильно настроить. Третья - как запустить несколько таких коллег параллельно и не потерять контроль.

Мой текущий setup: четыре активных проекта, 1-2 сессии Claude на каждый, два worktree-параллельных агента на рефакторинги, один Ralph-loop на бэкграундный проект, еженедельный /schedule на триаж PR. Это не лабораторный бенчмарк. Это рабочий режим, где один человек держит объём, который раньше требовал отдельной маленькой команды.

Если ты дочитал досюда - попробуй. Начни с одного приёма из этой статьи. Лучше с четвёртого (headless mode для daily standup) или седьмого (multi-file рефакторинг через Explore -> Plan -> Implement -> Commit). Они самые близкие к тому что ты уже делаешь вручную.

Через неделю вернёшься и попробуешь субагентов. Через месяц настроишь Agent Teams. Через три месяца у тебя будет свой Ralph-loop на ночные задачи.

Узкое место - не AI. Узкое место - ты, пока не начал.

Первые две части серии:
Часть 1: 10 фичей Claude Code, которые превратили одного разработчика в команду из 15 человек
Часть 2: 10 настроек Claude Code, до которых большинство разработчиков не доходит

Источники и ссылки по теме:
Claude Code: subagents · Claude Code: Agent Teams · Claude Code commands · Get Shit Done · Git worktree manual · GitHub Actions workflow syntax · Martin Fowler: Strangler Fig · InfoQ: Characterization Testing · Diffblue Testing Agent Benchmark · Geoffrey Huntley: Ralph Technique · RepoMirror Ralph Field Report · Claude Code Ultraplan · ClaudeFast: Source Leak Analysis

Об авторе: Кир, CTO и серийный предприниматель. Пишу про AI-инструменты, автоматизацию разработки и реальные интеграции в бизнесе. Telegram: @ai_integr.

Claude Code на автопилоте: субагенты, worktrees и CI/CD