Иногда действительно лучше промолчать, чем писать что-то ради «галочки». На днях мы в команде вспомнили о методичке Anthropic по Claude Code и поняли —  добавить к ней практически нечего, конечно, кроме наших советов об использовании этого инструмента. Все подходы, которые появились у нас с помощью этой практики, теперь вошли в официальные гайды лидеров в области ИИ-агентов. 

В общем, если вы хотите разобраться в агентном программировании — не проходите мимо этого перевода с комментариями руководителя отдела Flutter-разработки Surf Марка Абраменко.

Claude Code — это командная утилита для агентного программирования. В этом посте собраны советы и приёмы, которые оказались эффективными при использовании Claude Code для разных языков, кодовых баз и инфраструктур.

Недавно мы выпустили Claude Code — инструмент для работы с ИИ из командной строки, который был создан как исследовательский проект. С его помощью инженеры и исследователи Anthropic могут легко встроить Claude прямо в свою работу.

Claude Code намеренно создан низкоуровневым. Кроме того, он не навязывает никакую конкретную методику, а даёт почти «сырой» доступ к модели, не требуя определённого флоу. Поэтому утилита получилась гибкой, её легко можно настроить под себя, автоматизировать работу с ней и не волноваться за безопасность. Для тех, кто только осваивает агентное программирование, поначалу может быть непривычно, что в Claude Code столько свободы — потребуется время, чтобы найти и отработать собственные подходы. 

В этой статье описаны типовые паттерны использования, которые хорошо себя зарекомендовали и внутри самой Anthropic, и у внешних инженеров. Ничто из описанного ниже не является догмой; эти рекомендации — только отправная точка. Экспериментируйте и выбирайте то, что работает для вас!

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

1. Настраивайте рабочее окружение

Claude Code — агентный ассистент, который сам подтягивает контекст в промпты. Сбор контекста требует времени и токенов, но его можно оптимизировать, тонко настраивая окружение.

1. Создайте файлы CLAUDE.md

CLAUDE.md — особый файл, который Claude автоматически добавляет в контекст при запуске новой сессии. Это именно то место, куда удобно записывать такие вещи, как:

• часто используемые bash-команды;

• основные файлы и полезные функции;

• правила оформления кода;

• правила запуска тестов;

• внутренние привычки команды (например, как называем ветки, когда делаем merge, а когда rebase и прочие детали);

• настройку среды для работы (например, какую версию pyenv выбрать или какие компиляторы нужны);

• прочие мелочи, детали, предупреждения;

• да и вообще всё важное, что нужно помнить об этом проекте.

Какого-то специального формата для CLAUDE.md не требуется, но мы рекомендуем делать его коротким и понятным для людей. Например:

# Bash-команды
- npm run build: Собрать проект
- npm run typecheck: Прогнать тайпчекер

# Кодстайл
- Использовать синтаксис ES-модулей (import/export), не CommonJS (require)
- Деструктурировать импорты где возможно (например, import { foo } from 'bar')

# Флоу работы
- После серии изменений обязательно прогоняй typecheck
- Для скорости запускай отдельные тесты, не все сразу

Где размещать CLAUDE.md:

• в корне репозитория или там, откуда обычно запускается claude (самый частый вариант). Файл стоит закоммитить в git — так его увидят все члены команды. Либо использовать CLAUDE.local.md и добавить его в .gitignore;

• в любой родительской папке относительно точки запуска. Это удобно в монорепозиториях — например, если мы запускаем claude из root/foo, файлы root/CLAUDE.md и root/foo/CLAUDE.md оба подтянутся в контекст.

• в дочерних папках относительно точки запуска — здесь Claude будет подтягивать CLAUDE.md по мере обращения к соответствующим файлам;

• в домашней папке (~/.claude/CLAUDE.md) — такой файл применяется во всех сессиях claude.

Если запустить команду /init, Claude сам автоматически сгенерирует CLAUDE.md.

«Я бы сказал, что команда /init — скорее для тех, кто хочет попробовать. Не рекомендую запускать /init, не смотря при этом, что там. CLAUDE.md — очень важный файл. Если вы укажете там неактуальную информацию и забудете об этом, это будет часто стрелять вам в ногу. Рекомендую внимательно подойти к вопросу формирования CLAUDE.md. Особенно, если вы работаете в команде».

2. Пересматривайте CLAUDE.md

CLAUDE.md становится частью системных промптов Claude, так что относиться к нему нужно, как к любому частоупотребимому промпту: постепенно уточнять и тестировать эффективность. Типичная ошибка — добавлять в CLAUDE.md всё подряд и не переосмысливать структуру. Экспериментируйте и отслеживайте, что реально помогает модели.

Добавлять контент в CLAUDE.md можно вручную или через специальную клавишу # — Claude запишет нужную инструкцию сам. Во многих командах принято сразу коммитить доработки CLAUDE.md, чтобы ими пользовались все.

В Anthropic мы иногда прогоняем CLAUDE.md через наш Prompt Improver, иногда добавляем акцент (IMPORTANT, YOU MUST), чтобы повысить «послушание» модели.

3. Управляйте списком разрешённых инструментов Claude

По умолчанию Claude Code спрашивает разрешение на любые действия, способные изменить систему: запись в файлы, выполнение сложных bash-команд, запуск MCP-инструментов и другие. Такой консервативный режим призван защитить вашу рабочую среду. Но при желании список разрешённых действий можно расширить — например, добавить проверенные безопасные инструменты или команды, которые легко отменить (как тот же git commit).

Сделать это можно 4 способами:

• разрешить инструмент через всплывающее предложение в сессии (Always allow);

• Использовать команду /permissions для правки allowlist. Например, добавить Edit («разрешить всегда»), Bash(git commit:*) — «разрешить git commit», mcp__puppeteer__puppeteer_navigate — «разрешить навигацию с помощью Puppeteer MCP»;

• отредактировать вручную файлы .claude/settings.json или ~/.claude.json (первый из них стоит коммитить в git для общего доступа);

• для сессий — использовать флаг CLI --allowedTools.

«Рекомендую хранить типичные команды для работы с проектом в Makefile и указывать в CLAUDE.md, чтобы LLM перед началом работы «знакомилась» с ним. Это могут быть команды для запуска анализатора кода, кодогенерации, запуска тестов или самого приложения. Так вы сможете контролировать, что именно запускает LLM».

4. Поставьте gh CLI (если используете GitHub)

Claude умеет работать с gh CLI: создавать issues, открывать pull request, читать комментарии и пр. Даже без gh Claude всё равно может обращаться к GitHub API или MCP-серверу (если он установлен).

2. Дайте Claude больше инструментов

Claude видит ваше shell-окружение, поэтому вы можете дать ему такие же утилиты и скрипты, какие используете сами. А ещё он умеет подключаться к более сложным инструментам через MCP и REST API.

1. Интеграция с bash-утилитами

Claude наследует переменные окружения bash, получая доступ ко всем вашим инструментам. Он знает об основных утилитах Unix и gh, но если вы используете что-то своё — «расскажите» Claude:

• название команды и примеры её использования;

• попросите прогнать --help для документации;

• зафиксируйте полезные инструменты в CLAUDE.md.

2. Интеграция с MCP

Claude Code работает и как сервер, и как клиент MCP. В режиме клиента он может подключаться к нескольким MCP-серверам — через конфиг проекта, глобальный конфиг, либо файл .mcp.json (последний стоит коммитить в репозиторий).

С MCP удобно запускать Claude с флагом --mcp-debug для диагностики конфигурации.

3. Кастомные slash-команды

Если у вас есть задачи, которые повторяются (например, локальная отладка, разбор логов и т.п.), удобно сохранить готовые шаблоны запросов в Markdown‑файлы в папке .claude/commands. Потом их можно вызывать прямо из меню slash‑команд, набрав /. Так эти команды сразу будут доступны всей команде.

В кастомных slash‑командах можно использовать специальный аргумент $ARGUMENTS, чтобы передавать нужные параметры прямо при их запуске.

Пример команды для автоматизации исправления GitHub issue:

Please analyze and fix the GitHub issue: $ARGUMENTS.

Follow these steps:

1. Use gh issue view to get the issue details

2. Understand the problem described in the issue

3. Search the codebase for relevant files

4. Implement the necessary changes to fix the issue

5. Write and run tests to verify the fix

6. Ensure code passes linting and type checking

7. Create a descriptive commit message

8. Push and create a PR

Remember to use the GitHub CLI (gh) for all GitHub-related tasks.

Положив это в .claude/commands/fix-github-issue.md, мы получим команду /project:fix-github-issue. Пример вызова: /project:fix-github-issue 1234 — Claude сам разберёт и исправит issue #1234. Личные команды удобно хранить в папке ~/.claude/commands — они будут доступны во всех сессиях.

«Команды — реально крутая штука, которой не хватает тому же Cursor. Дополнительные юзкейсы: 

1. Команда для запуска код-ревью изменений. Вы также можете попросить Claude смотреть только дифф от main-ветки или изменения в stage.

2. Команда для запуска анализа кода — когда Claude помогает исправлять ошибки анализатора, которые не фиксятся автоматически. 

3. Команда для поиска багов и возможных недочётов в реализации».

3. Используйте проверенные методы

В Claude Code нет «единственно правильного» способа работы — каждый выбирает свой. Вот несколько подходов, которые уже хорошо зарекомендовали себя на практике.

1. Исследуйте, планируйте, пишите код и фиксируйте результат

Этот подход подходит почти для любых задач.

1. Сначала попросите Claude изучить нужные файлы, изображения или ссылки. Можно дать общий ориентир («файл, который отвечает за логирование») или сразу назвать конкретный файл (logging.py). Главное на этом этапе — чётко сказать, что код писать пока не нужно.

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

2. Попросите Claude составить пошаговый план. Чтобы ИИ подумал «глубже», используйте команду-слово вроде think, think hard или ultrathink — так он потратит больше «времени на размышления» и предложит больше вариантов.

3. Если план нравится, попросите оформить его в отдельный документ или GitHub issue, чтобы можно было вернуться к этой точке.

4. Дайте задание на реализацию кода, параллельно прося проверять, насколько обоснованы и корректны отдельные шаги.

5. Когда результат готов, попросите сделать коммит и создать pull request. В этот же момент можно обновить README или changelog с описанием изменений.

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

«Использование “think, think hard или ultrathink” — это не опция, а база. Если вы использовали Cursor и привыкли сразу выбирать «думающие» модели, то Claude Code не такой. Единственный способ маршрутизировать его на «думающую» версию — это явно написать, чтобы он думал побольше. Не забывайте об этом, ведь зачастую он экономит ресурсы и не думает над задачей слишком много, если ему это не нужно. Как по-человечески».

2. Пишите тесты и фиксируйте результат. Пишите код, разбивайте на итерации и снова фиксируйте результат

Это любимый подход команды Anthropic для задач, которые легко проверить юнит‑ или интеграционными тестами.

1. Сначала попросите Claude написать тесты на ожидаемые сценарии в стиле TDD. Обязательно уточните: код пока не писать, даже если нужной функции в проекте ещё нет.

2. Запустите тесты — на этом этапе они должны упасть. Ещё раз напомните Claude, что пока не нужно генерировать код.

3. Зафиксируйте результат тестов.

4. Теперь дайте задание написать реализацию, которая пройдёт все тесты, не меняя сами тесты. Пусть Claude дорабатывает код итерациями, пока всё не станет «зелёным». Можно подключить подагентов, чтобы они проверили, не «подогнана» ли реализация слишком узко под эти тесты.

5. Снова коммитим изменения.

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

3. Пишите код, делайте скриншот, запускайте новую итерацию

По похожей схеме — как с тестами — задайте Claude визуальную цель:

1. Дайте ему возможность делать скриншоты в браузере — например, через Puppeteer MCP или просто вручную — через копипаст.

2. Передайте макет в виде картинки — вставьте скриншот, перетащите файл или укажите путь к изображению.

3. Попросите Claude написать код, сделать скриншоты результата и дорабатывать его, пока результат не будет совпадать с макетом.

4. Когда увидите, что всё устраивает — попросите сделать коммит.

Как и у человека, результаты работы Claude заметно улучшаются при доработках. Первый вариант может быть неплохим, но уже после 2–3 итераций он обычно выглядит гораздо лучше. Лучшие результаты будут тогда, когда Claude сможет сам видеть свой вывод — так дайте ему такие инструменты.

«Dart и Flutter уже выпустили свои MCP, которые позволяют Claude, например, подключаться к рантайм-дебагу. А ещё — дают возможность перезапустить приложение и посмотреть «дерево виджетов»».

4. Безопасный YOLO-режим

Вместо ручного одобрения каждого действия можно использовать ключ --dangerously-skip-permissions — так Claude выполнит всю сессию без прерываний. Это удобно для флоу вроде автоматической правки ошибок линтера или генерации шаблонного кода.

Но запуск произвольных команд рискован: возможна потеря данных, повреждение системы, утечки — например, через prompt injection. Поэтому применять --dangerously-skip-permissions стоит только в изолированных контейнерах без доступа к интернету — пример такой разработки вы найдёте здесь.

5. Q&A по коду

Когда вы только подключаетесь к новому проекту, используйте Claude Code как инструмент для изучения и ориентирования в кодовой базе. Общайтесь с ним так же, как с коллегой‑разработчиком при парном программировании — задавайте вопросы напрямую.

Claude умеет самостоятельно «прогуляться» по коду и найти ответы на самые разные общие вопросы, например:

• Как устроено логирование?

• Как добавить новый API‑endpoint?

• Что делает async move { ... } на 134‑й строке в файле foo.rs?

• Какие особые случаи обрабатывает CustomerOnboardingFlowImpl?

• Почему на 333‑й строке мы вызываем foo(), а не bar()?

• Как переписать строку 334 из baz.py на Java?

У нас в Anthropic такой подход стал основой процесса онбординга. Он заметно ускоряет вливание новичков в проект и снимает нагрузку с более опытных инженеров. Никаких особенных промптов не нужно — просто задавайте вопросы, и Claude сам изучит код, чтобы найти ответы.

6. Работа с git через Claude

Claude умеет работать с большинством git‑операций, и многие инженеры в Anthropic проводят через него больше 90% своей работы с git.

Например, он может:

• искать по истории изменений, чтобы ответить на вопросы вроде: «что попало в версию v1.2.3?», «кто отвечает за эту фичу?» или «почему API сделали именно так?». Лучше попросить Claude просмотреть историю git, если вам нужен ответ на такие вопросы;

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

• выполнять сложные git‑операции: откатывать файлы, разбирать конфликты при rebase, сравнивать и объединять патчи.

7. Работа с GitHub

Claude Code поддерживает множество операций с GitHub. Например:

• создание pull‑request’ов. Он понимает сокращение pr и сам формирует подходящее сообщение к коммиту, учитывая разницу в коде (diff) и весь контекст;

• быстрое исправление замечаний из ревью. Достаточно написать Claude, чтобы он поправил комментарии к вашему PR (можно уточнить детали), и он внесёт изменения, а потом отправит их обратно в ту же ветку PR;

• исправление упавших сборок или предупреждений линтера;

• разбор и сортировка задач. Можно попросить Claude пройтись по всем открытым issues в репозитории, распределить их по категориям и приоритизировать.

С таким подходом не нужно держать в голове синтаксис команд gh CLI — Claude сделает всё за вас, автоматизировав обычные задачи.

8. Работа с Jupyter Notebook через Claude

Исследователи и дата‑сайентисты в Anthropic часто используют Claude Code для чтения и редактирования Jupyter notebooks. Он умеет анализировать результаты, в том числе изображения, что позволяет быстро изучать данные и взаимодействовать с ними.

Специальных команд или строгого сценария работы тут нет, но мы советуем открывать Claude Code и нужный .ipynb‑файл рядом, например, в двух вкладках VS Code.

Ещё один полезный трюк — попросите Claude привести ноутбук (или графики внутри него) в более аккуратный и красивый вид перед тем, как показывать коллегам. Если сказать, что нужно сделать его «эстетически приятным», Claude лучше поймёт, что важно не только содержание, но и зрительное восприятие. Так модель сфокусируется на визуальной передаче.

4. Оптимизируйте рабочий процесс

Эти советы подойдут для любых сценариев работы с Claude Code.

1. Максимально конкретизируйте инструкции

Чем чётче требования, тем выше эффективность Claude (особенно с первой попытки). Например:

Claude может догадываться о том, что вы имеете в виду, но не может читать ваши мысли. Больше конкретики — лучше результат.

«Если вы понимаете, что ваш промпт занимает больше одного предложения — рекомендую писать его в отдельном md-файле. Окошко терминала обладает не самым юзерфрендли UX в мире, а в MD-формате вполне просто ссылаться на файлы для контекста, а также акцентировать внимание LLM на чём-то путём форматирования».

2. Давайте Claude изображения

Claude хорошо воспринимает скриншоты и диаграммы:

• вставляйте скриншоты прямо в чат. Совет для macOS: нажмите сочетание клавиш cmd+ctrl+shift+4, чтобы сделать скриншот в буфер обмена, а затем вставьте его нажатием ctrl+v (обратите внимание, это не обычный cmd+v и не сработает при удалённой работе);

• просто перетаскивайте изображения мышкой в окно ввода сообщения — Claude сразу увидит картинку;

• можно указать путь к файлу с изображением, чтобы Claude его подгрузил.

Это особенно полезно, когда вы работаете с дизайном интерфейсов и показываете Claude эталонный макет. Также изображения помогают при анализе и отладке с визуальными графиками и диаграммами. Даже если вы не добавляете картинки в контекст, будет полезно явно сказать Claude, что для вас важно, чтобы результат выглядел красиво и аккуратно.

«Sonnet 4 очень неплохо верстает даже по изображению. Особенно, если нужно сделать PoC — это хороший вариант. Если же вы хотите сразу получить что-то более-менее похожее на production-ready, рекомендую посмотреть в сторону Figma MCP (который, если что, тоже неплохо работает с изображениями)».

3. Явно указывайте файлы для работы

Когда вы хотите, чтобы Claude посмотрел или отредактировал определённые файлы, лучше явно их упомянуть. Для этого удобно использовать автодополнение: просто начните набирать имя файла или папки, и Claude быстро подставит нужные пути из вашего репозитория. Так вы точно не ошибётесь и не потеряете время на разъяснения — с чем именно нужно работать.

«Хочу обратить внимание на эту рекомендацию. Передавать максимум контекста, который вы сами знаете — значит, получать наиболее предсказуемый результат. Не мучайте LLM и не заставляйте его искать файлы, расположение которых вы сами знаете».

4. Давайте Claude ссылки

Если нужно, чтобы Claude что‑то прочитал или скачал, просто вставляйте нужные URL прямо в свой запрос.
Например, добавьте ссылку на документацию или статью — Claude её откроет и учтёт в работе.

Чтобы каждый раз не подтверждать доступ к одному и тому же домену (например, docs.foo.com), добавьте этот домен в разрешённый список через команду /permissions.

5. Корректируйте по ходу работы

В Claude Code есть режим авто‑принятия действий (вкл./выкл. — Shift+Tab), в котором он может работать самостоятельно. Но на практике лучшие результаты достигаются, когда вы активно участвуете в процессе и направляете его.

Идеально — подробно объяснить задачу в самом начале. Но корректировать действия Claude можно в любой момент.

Вот 4 полезных инструмента для оперативного корректирования:

1. Попросите составить план перед тем, как писать код. Прямо скажите, что код генерировать не нужно, пока вы не одобрите план.

2. Нажмите Escape, чтобы остановить Claude (на этапе размышлений, вызова инструментов или правок файлов), при этом контекст сохранится, и вы сможете уточнить или поменять инструкцию.

3. Двойное нажатие Escape вернёт вас к предыдущему запросу, где можно изменить формулировку и попробовать другой подход. Повторяйте до тех пор, пока не получите нужный результат.

4. Попросите отменить изменения — часто в сочетании с пунктом 2, чтобы затем попробовать другой вариант решения.

Иногда Claude попадает в цель с первой попытки. Но в большинстве случаев использование этих приёмов позволяет получить более качественный результат быстрее.

6. Используйте /clear для сброса контекста

Во время долгих сессий окно контекста у Claude постепенно забивается лишним — обрывками разговора, содержимым файлов, командами. Это может замедлять работу и сбивать его с толку.
Чтобы этого не происходило, чаще «очищайте» контекст между задачами командой /clear — так вы будете начинать следующий этап работы «с чистого листа».

7. Используйте чек‑листы и черновики для сложных задач

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

Можно сделать список в Markdown‑файле или даже оформить его как GitHub issue, а дальше работать так:

1. Попросите Claude запустить lint‑проверку и записать все найденные ошибки (с именами файлов и номерами строк) в этот чек‑лист.

2. Дайте задание исправлять их по одной: фиксить, проверять и отмечать выполненные, прежде чем переходить к следующей.

«Возможно, в этой части мысль автора недостаточно раскрыта. Разница заключается в том, что вы можете использовать в разных чатах один MD-файл с чек-листом. 

И вы даже можете давать разные задачи из этого чек-листа разным чатам. Это очень полезно при выполнении особо сложных задач, которые не влезают в один контекст. Алгоритм работы с этим чек-листом примерно такой: 

1. «Сделай 1 задачу из чек-листа».

2. Получаете результат.

3. Передаёте результат и говорите «сделай вторую задачу из чек-листа, первая уже завершена».

Таким образом можно реализовать целую фичу».

8. Передавайте данные в Claude

Есть несколько способов передать данные в Claude:

• скопировать и вставить их прямо в свой запрос (самый распространённый способ);

• передать данные через конвейер в Claude Code (например, cat foo.txt | claude) — особенно удобно для логов, CSV‑файлов и больших наборов данных;

• поручить Claude загрузить данные с помощью bash‑команд, инструментов MCP или пользовательских slash‑команд;

• попросить Claude прочитать файлы или получить данные по URL (работает и с изображениями).

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

«Некоторые ребята в нашей команде используют MCP для Jira и передают ему целые задачи. Это бывает удобно, особенно, если несколько багов пересекаются по контексту».

5. Используйте headless mode для автоматизации

Claude Code поддерживает headless mode для неинтерактивных сценариев: CI, pre-commit-хуков, билд-скриптов и автоматизации. Чтобы включить этот режим, используйте флаг -pс вашим промптом, а для потокового вывода в формате JSON — флаг--output-format stream-json.

Обратите внимание: headless mode не сохраняет состояние между сессиями, запускать его надо каждый раз.

1. Используйте Claude для автоматической сортировки задач

Headless mode отлично автоматизирует реакцию на GitHub-события (например, анализирует создание issue). Так, в публичном репозитории Claude Code Claude применяют для анализа новых задач и автоматического назначения им подходящих меток.

2. Используйте Claude как линтер

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

6. Повышайте эффективность с помощью многопоточных рабочих процессов Claude

Одни из самых мощных сценариев работы строятся на запуске нескольких экземпляров Claude параллельно.

1. Один Claude пишет код, другой проверяет

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

1. Используйте Claude для написания кода.

2. Выполните команду /clear или запустите второго Claude в другом терминале.

3. Попросите второго Claude проверить работу первого.

4. Запустите ещё одного Claude (или снова выполните /clear), чтобы он прочитал и сам код, и комментарии из проверки.

5. Попросите этого Claude внести правки в код на основе полученного фидбэка.

Аналогично можно поступить и с тестами: один Claude пишет тесты, другой — код, чтобы эти тесты проходили. Можно даже наладить «обмен сообщениями» между экземплярами Claude, дав им отдельные рабочие черновики и указав, куда писать и откуда читать.

Такое разделение даёт более хорошие результаты, чем в случае, когда все задачи выполняет один Claude.

«Для этой задачи можно завести отдельную команду и обращаться к ней через слэш, подробнее об этом написано в пункте 2.3».

2. Используйте несколько копий репозитория

Вместо того чтобы ждать, пока Claude закончит каждый шаг, инженеры Anthropic делают так:

1. Создают 3 – 4 отдельные копии репозитория в разных папках.

2. Открывают каждую папку в отдельной вкладке терминала.

3. Запускают Claude в каждой папке с разными заданиями.

4. По очереди проверяют прогресс и одобряют или отклоняют запросы на выполнение действий.

3. Используйте git worktree

Этот способ особенно удобен, когда нужно параллельно вести несколько независимых задач. Это более «невесомая» альтернатива множественным копиям репозитория.

Git worktrees позволяют извлечь несколько разных веток из одного репозитория в отдельные папки. У каждой worktree — свой рабочий каталог с собственными файлами, но при этом они все используют одну и ту же историю Git и общий reflog.

Используя git worktrees, вы можете запускать несколько сессий Claude одновременно на разных частях проекта, каждая из которых будет работать над своей задачей. Например, один Claude может рефакторить систему аутентификации, а другой — параллельно разрабатывать отдельный компонент визуализации данных. Посколькц задачи не пересекаются, каждый Claude работает на полной скорости, не ожидая чужих изменений и без конфликтов при слиянии.

Пример работы:

1. Создайте worktree:

git worktree add ../project-feature-a feature-a

2. Запустите Claude в этой worktree:

cd ../project-feature-a && claude

При необходимости создайте дополнительные worktrees (повторите шаги 1–2 в новых вкладках терминала).

Полезные советы:

• Используйте единообразные схемы именования worktrees.

• Держите по одной вкладке терминала на каждую worktree.

• Если вы на Mac и используете iTerm2 — настройте уведомления, чтобы видеть, когда Claude требует вашего внимания.

• Открывайте разные worktrees в отдельных окнах IDE.

• После завершения работы очищайте лишние worktrees:

git worktree remove ../project-feature-a

4. Headless mode с собственным скриптом

Команда claude -p (headless mode) позволяет программно интегрировать Claude Code в более крупные рабочие процессы — с помощью встроенных инструментов и системного промпта. Есть два основных подхода к работе в этом режиме:

1. Масштабное распараллеливание (fanning out) — подходит для больших миграций или аналитики, например, анализа тональности в сотнях логов или обработки тысяч CSV‑файлов.

1.1. Поручите Claude написать скрипт, который составит список задач. Например, список из 2000 файлов, которые нужно перенести с фреймворка A в фреймворк B.

1.2. Запустите цикл по задачам, вызывая Claude программно для каждой. Передавайте ему саму задачу и набор инструментов, которые он может использовать. Например:

claude -p "migrate foo.py from React to Vue. When you are done, you MUST return the string OK if you succeeded, or FAIL if the task failed." --allowedTools Edit Bash(git commit:*)

1.3. Запустите скрипт несколько раз и доработайте промпт, пока не получите нужный результат.

2. Конвейер (pipelining) — интеграция Claude в существующие пайплайны обработки данных.

2.1. Вызывайте:

claude -p "<your_command>" --json | your_command

где your_command — следующий шаг в вашем пайплайне.

При этом JSON‑вывод (необязательный) помогает структурировать данные для автоматической обработки.

Для обоих случаев полезно использовать флаг --verbose для отладки выполнения команд Claude. В продакшене мы обычно советуем выключать verbose‑режим, чтобы получать более чистый вывод.

---

Автор: Борис Черни (Boris Cherny). В работе учтён опыт многих членов сообщества пользователей Claude Code и инженеров Anthropic, чья практическая смекалка и экспертиза легли в основу этих рекомендаций. Особая благодарность: Daisy Hollman, Ashwin Bhat, Cat Wu, Sid Bidasaria, Cal Rueb, Nodir Turakulov, Barry Zhang, Drew Hodun и многим другим коллегам.