# Промпт-инжиниринг умер. Да здравствует инжиниринг циклов.

*Почему руководитель Claude Code в Anthropic только что объявил конец эпохи «заклинателей ИИ» — и что приходит на смену.*

> Борис Черный, ведущий разработку Claude Code в Anthropic, говорит, что больше не пишет промпты — он пишет циклы. Разбор: смерть промпт-инжиниринга и рождение инжиниринга циклов, агентные рабочие процессы, самокорректирующиеся агенты, почему проверка важнее искусства формулировки и как тот же цикл работает в продакшене.

— The Fractera Team, 2026-06-14

## Цитата, которая разрушила иллюзию

Несколько дней назад одна фраза **Бориса Черного** — инженера, ведущего разработку **Claude Code** в **Anthropic** — тихо прокатилась ударной волной по сообществу разработчиков.

На публичной панели Черный приоткрыл, как люди, строящие самый сложный в мире кодовый ИИ, на самом деле работают со своими же моделями. Сказанное не просто спорит с общепринятым — оно объявляет устаревшей целую едва народившуюся дисциплину:

> Я больше не пишу промпты для Claude. У меня работают циклы, которые сами обращаются к Claude и сами решают, что делать дальше. Моя работа — писать циклы.
>
> — Борис Черный · Claude Code, Anthropic

Дайте этому осесть.

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

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

## Смена парадигмы: от микроменеджмента к архитектуре системы

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

### Фаза 1 — линейный промпт (человек как узкое место)

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

```
ты пишешь промпт  ─▶  ИИ пишет код  ─▶  ты находишь баг  ─▶  ты правишь промпт  ─┐
     ▲                                                                          │
     └──────────────────────────  снова руками  ◀─────────────────────────────────┘
```

В этой парадигме **узкое место — человек.** Вы пишете промпт, читаете ответ, замечаете синтаксическую ошибку, вставляете её обратно в чат и молитесь, чтобы модель не забыла контекст через пять шагов. Ощущается продуктивно. На деле это изматывающий микроменеджмент, который не масштабируется — и уж точно не работает, пока вы спите.

### Фаза 2 — инжиниринг циклов (автономный контур)

То, что описывает Черный, — это **инжиниринг циклов**: агентные процессы, где человек выходит из контура исполнения целиком. Вы перестаёте вести машину. Вы строите трассу и даёте машине проходить круги.

Вместо промпта, решающего задачу, вы пишете программный **цикл**, который встраивает ИИ в автоматический круг исполнения и проверки:

1. **Цель.** Человек ставит одну задачу верхнего уровня — «построй этот эндпоинт API и добейся 98 % покрытия тестами».
2. **Действие.** ИИ пишет первую версию кода.
3. **Проверка.** Автоматическая среда — компилятор, линтеры, юнит-тесты, ваш CI — прогоняет код и ловит каждую ошибку.
4. **Самокоррекция.** При провале система забирает трассу ошибки, отдаёт её ИИ как новую инструкцию и велит попробовать снова.

```
ты ставишь цель
     │
     ▼
ИИ пишет код  ─▶  CI прогоняет все проверки  ─▶  зелено?  ─▶  ✦ отгружено
     ▲                      │
     │                      ▼  (красно)
     └──  ИИ читает логи и переспрашивает сам себя
```

Цикл идёт на машинной скорости, перемалывая десятки итераций, сам себя правит и сам себя лечит, пока не выполнены условия проверки. Вы не набрали ни одного уточнения. Вы не писали промпты — вы построили трассу, а модель прошла каждый круг сама.

## Настоящее умение — не писать код. Настоящее умение — написать судью.

Вот часть, которую почти все упускают, — а в ней вся игра. Трудное в цикле — **не** сгенерировать код. Модели уже пугающе хороши в этом. Трудное — это **то, что решает, хорош ли код.**

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

Значит, умение следующего десятилетия — не искусство формулировки. Это **проектирование проверки**: непробиваемых систем валидации, которые позволяют ИИ безопасно разговаривать с самим собой и не улететь с обрыва. Это более сложная, более редкая и куда более ценная инженерия, чем подбор нужных слов.

## От философии к продакшену: как мы собрали цикл

Пока остальной технический мир разбирает цитату Черного в соцсетях, настоящий вызов выглядит неромантично: **как построить инфраструктуру инжиниринга циклов, которая работает в продакшене — вне внутренних лабораторий Anthropic?**

Замкните цикл вокруг одной модели — и быстро упрётесь в стены реального мира: деградацию контекстного окна, галлюцинаторные спирали смерти и отсутствие памяти в масштабе проекта. В [%SITE%](/ru) мы весь прошлый год относились к философии Черного не как к предсказанию, а как к **архитектурному чертежу** — и построили цикл разработки, который переживает ровно эти способы сломаться.

![Схема цикла разработки Fractera — один запрос проходит через оркестрацию, кодовых агентов и графовую память до протестированного, развёрнутого кода](media:development-loop.jpg)
*Цикл разработки Fractera — идея Черного, разведённая в рабочем пространстве, которым вы владеете. [Посмотреть полную анатомию](https://www.fractera.ai/ai-development-loop).*

### Анатомия цикла продакшн-уровня

Чтобы циклы стали пригодны для настоящего софта, придётся вырасти из «один ИИ разговаривает сам с собой». Нужны оркестрация, специализированные агенты и постоянный хребет памяти:

- **Мультиагентная оркестрация.** Вместо бесконечного цикла вокруг одной модели оркестратор разбирает команду верхнего уровня и отправляет под каждую микрозадачу самого подходящего агента — одного на трудную логику, другого на рефакторинг, третьего на быструю разведку.
- **Хребет графовой памяти.** Главный риск автономного цикла — эффект амнезии: пятнадцать кругов вокруг упрямого бага, и агент теряет из виду общую архитектуру. Граф знаний работает как непрерывная, нестираемая память, поэтому каждый круг сверяется с настоящими правилами и стилем вашей кодовой базы.
- **Неотменяемый контур проверки.** Цикл завершается только тогда, когда набор тестов и развёртывание вернули ноль ошибок. Провалилось развёртывание — логи мгновенно обрастают контекстом из памяти и летят обратно агентам на автоматическое лечение.

## Новая должностная инструкция инженера

Мы уходим от написания кода, проходим мимо написания промптов и попадаем прямо в **строительство когнитивных конвейеров.** Ремесло — больше не инструкция, а система, внутри которой инструкция исполняется.

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

Хотите заглянуть под капот — оркестрация, графовая память и круг «собери — проверь — исправь» в строгих инженерных подробностях? — [Разобрать анатомию автономных циклов ИИ](https://www.fractera.ai/ai-development-loop)

Эпоха промпт-инжиниринга официально позади. Остался единственный вопрос — тот самый, на который Черный уже ответил себе: **вы всё ещё пытаетесь разговаривать со своим ИИ — или уже строите циклы, которые дают ему работать?**

Источник: широко разошедшийся пост в LinkedIn Гильермо Флора, вынесший на публику слова Бориса Черного. Цитата приведена в том виде, в котором разошлась; архитектура и разбор — наши собственные.

## FAQ

### Что такое «инжиниринг циклов» и почему он вытесняет промпт-инжиниринг?

Инжиниринг циклов — это написание автоматических процессов, которые сами обращаются к ИИ, прогоняют его результат через проверку (тесты, CI, компилятор), возвращают провалы обратно как новые инструкции и повторяют, пока результат не станет верным. Борис Черный, ведущий Claude Code в Anthropic, сказал, что больше не составляет промпты руками: он пишет циклы, которые делают это за него. Суть в том, что узким местом никогда не был промпт — узким местом был человек внутри контура обратной связи.

### Как автономный цикл разработки устроен в продакшене?

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

### Нужно ли уметь программировать, чтобы запустить автономный цикл разработки?

Нет. Вы описываете цель обычными словами, а система превращает её в конкретную задачу разработки, выбирает агента и крутит цикл. Вы наблюдаете, как проект обретает форму в реальном времени; код вы не пишете.