Если вы в последнее время заглядывали в техно-Twitter, то наверняка видели, как люди обсуждают «Ralph Wiggum» так, будто это чит-код. Мемный нейминг делу не помогает, но идея вполне реальна: это официальный плагин для Claude Code, который превращает одиночный промпт в устойчивый цикл. Агент продолжает работать, исправляя собственные ошибки, пока действительно не дойдёт до финишной черты, которую вы задали.

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

Объяснение за одну минуту

Ralph Wiggum — это цикл. Вы даёте Claude Code задачу, он над ней работает, а когда пытается завершиться, хук на событие Stop блокирует выход и снова подаёт на вход тот же самый промпт. Файлы, которые он только что изменил, остаются на месте, поэтому каждая итерация может опираться на предыдущую. Цикл можно ограничить максимальным числом итераций и/или «обещанием о завершении» (completion promise) — строкой, которую Claude должен вывести только тогда, когда задача действительно выполнена.

Если промпт точный, а результат поддаётся проверке (тесты проходят, линтер чист, сборка успешна), Ralph обычно сходится. Если промпт расплывчатый — он начинает блуждать.

Geoffrey Huntley, который популяризировал эту технику, описывает её предельно просто: «Ralph — это Bash-цикл». Плагин упаковывает эту идею в Claude Code, чтобы её можно было безопасно запускать прямо в сессии.

Пример того, что Ralph Wiggum заменил лично мне

Больше мне не нужно держать вот этот кусок в файле CLAUDE.md:

4. **Инсайты обязательны.**
   Всегда запускай:

   ```bash
   sail artisan insights --no-interaction --format=json --flush-cache
   ```

   Исправь **все** проблемы, прежде чем переходить к следующей задаче, и напиши краткое резюме.

Как цикл работает на самом деле (без жаргона)

Представьте себе стиральную машину в режиме повтора:

1. Вы загружаете задачу (промпт).

2. Агент прогоняет цикл (правит файлы, запускает тесты).

3. Он пытается остановиться.

4. Плагин говорит «ещё рано» и снова кладёт ту же задачу внутрь.

5. Повторяется до тех пор, пока задача не выполнена или вы не упёрлись в жёсткий лимит.

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

Именно поэтому все в восторге: приличный промпт плюс цикл способны обойти одиночный «one-shot» промпт, особенно на скучной, механической работе.

Почему люди им одержимы (и почему это не просто хайп)

Со стороны весь этот ажиотаж выглядит как празднование «one-shot»-побед или восторг от бота, который «просто не останавливается». Один из недавних тредов в X (4 января 2026) подытожил это фразой «he just keeps going» — и она зашла, потому что в этом и есть вся суть привлекательности: настойчивость без необходимости нянчиться.

Под капотом же эта одержимость вполне практична:

• Настойчивость бьёт совершенство. One-shot-промпты часто проваливаются. Цикл превращает провал в обратную связь.

• Смещает навык в сторону проектирования промптов. Вы чётко определяете «готово», а агент итерациями добивается этого.

• Подходит для работы с объективными проверками. Тесты, линтеры, шаги сборки и документация — отличные сигналы.

Если вы когда-нибудь наблюдали, как агент доходит до 80% и затем встаёт, цикл Ralph — это те самые недостающие 20%.

Где Ralph блистает (с реалистичными примерами)

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

1) Рефакторинг легаси или миграция фреймворка

Цель: заменить зависимость или фреймворк, не меняя поведения.

/ralph-loop "Перенеси тесты с Jest на Vitest.
Критерии успеха:
- Все тесты проходят
- Снапшоты не изменились
- Конфигурационные файлы обновлены
- README обновлён
Выведи <promise>DONE</promise> по завершении." \
--max-iterations 25 \
--completion-promise "DONE"

Почему работает: измеримое «готово», и агент может безопасно итерировать с тестами.

2) Спринт по покрытию тестами

Цель: добавить тесты для непокрытых веток кода.

/ralph-loop "Добавь тесты для всех непокрытых функций в src/utils.
Критерии успеха:
- Покрытие >= 85%
- Все тесты зелёные
- Нет ошибок линтера
Выведи <promise>COMPLETE</promise> по завершении." \
--max-iterations 20 \
--completion-promise "COMPLETE"

Почему работает: агент может проверить успех по покрытию и тестам.

3) Создание приложения с нуля (greenfield)

Цель: собрать простое работающее приложение, которое позже можно доработать.

/ralph-loop "Собери минимальный TODO API.
Требования:
- CRUD-эндпоинты
- Валидация входных данных
- Тесты для каждого эндпоинта
- README с документацией API
Выведи <promise>READY</promise> по завершении." \
--max-iterations 30 \
--completion-promise "READY"

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

4) Стандартизация кодовой базы

Цель: применить единообразные паттерны по всему репозиторию.

/ralph-loop "Стандартизируй обработку ошибок в src/:
- Замени строковые ошибки на подклассы Error
- Добавь тесты на ошибки там, где их нет
- Не меняй публичный API
Выведи <promise>STANDARDISED</promise> по завершении." \
--max-iterations 15 \
--completion-promise "STANDARDISED"

Почему работает: это повторяющаяся работа с чёткими ограничениями.

Промпт, который заставляет Ralph вести себя как надо

Ralph не делает вас продуктивным сам по себе. Он делает продуктивными повторяемые промпты. Вот шаблон промпта, который обычно сходится:

ЗАДАЧА:
<одно предложение, описывающее изменение>
КРИТЕРИИ УСПЕХА:
- <измеримое требование 1>
- <измеримое требование 2>
- <тесты/сборка/линтеры должны проходить>
ПРОЦЕСС:
1) Сделай минимальное изменение, приближающее к успеху
2) Запусти тесты или проверку
3) Исправь падения и повтори
4) Если застрял после N итераций — резюмируй блокеры и предложи следующие шаги
ВЫВОД:
<promise>ВАШЕ_ОБЕЩАНИЕ</promise> только когда выполнены ВСЕ критерии

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

Ограждения по здравому смыслу (используйте их каждый раз)

• Всегда задавайте --max-iterations. Это ваш страховочный стоп-кран.

• Относитесь к «обещаниям о завершении» как к хрупкой вещи. Под капотом это обычная строка с точным совпадением, а не умное условие остановки.

• Держите область задачи небольшой. Маленькие порции сходятся быстрее и их проще ревьюить.

• Просматривайте дифф. Не мёржите вслепую; относитесь к выводу как к PR от джуниора в команде.

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

Если вы проигнорируете эти правила, можно сжечь время, токены и доверие к результату.

Это «маст-хэв»?

Если в вашей работе есть что-либо из перечисленного, сложно оценить пока не попробуешь:

• повторяемые рефакторинги

• поддержка тестов

• генерация документации

• исправление линтера или стандартизация

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

С чего начать (быстро и безопасно)

1. Установите плагин через систему плагинов Claude Code.

2. Начните с небольшой, проверяемой задачи.

3. Задайте --max-iterations 10-20, чтобы ограничить расходы.

4. Используйте «обещание о завершении» только тогда, когда «готово» можно проверить.

5. Просматривайте дифф, прежде чем доверять результату.

Если цикл пошёл вразнос, его можно отменить командой /cancel-ralph и попробовать снова с более строгим промптом.