Roman Kryvolapov Engineering Blog

Как работает Claude Code

Привет!

У меня на сайте уже есть три статьи про Claude Code: справочник команд и настроек, разбор хуков и практики работы. Все три отвечают на вопрос «что нажать и как настроить». Эта отвечает на другой вопрос: как оно устроено внутри.

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

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

Всё описанное сверено с официальной документацией и с установленной у меня версией 2.1.328 в ноябре 2026 года. Claude Code выходит несколько раз в неделю, поэтому мелкие детали меняются быстро, а устройство в целом — медленно. Пути на диске я показываю так, как они выглядят у меня на Windows, и рядом говорю, где это на macOS и Linux.

Модель и харнес: кто что делает

Начнём с главного разделения. В Claude Code две части, и их постоянно путают.

Модель — это нейросеть Claude на серверах Anthropic. Она умеет одно: получить текст и выдать текст. Она не видит ваш диск, не может запустить команду и ничего не помнит между запросами.

Харнес (harness, «обвязка») — это программа claude, которая работает на вашем компьютере. Именно её вы устанавливаете. Она читает файлы, запускает команды, показывает интерфейс, спрашивает разрешения, хранит историю и решает, что отправить модели в каждом запросе.

Модель думает, харнес делает. Связаны они через инструменты (tools). Инструмент — это функция, которую харнес умеет выполнить: «прочитай файл», «запусти команду», «найди строку». Харнес описывает модели список инструментов, а модель в ответе может написать не обычный текст, а просьбу: «вызови инструмент чтения с таким-то путём». Харнес выполняет просьбу и возвращает модели результат.

ваш компьютер серверы Anthropic
┌──────────────────────────────┐ ┌────────────────────┐
│ харнес (программа claude) │ запрос → │ │
│ │ │ модель Claude │
│ интерфейс, разрешения, │ ← ответ │ │
│ история, настройки │ └────────────────────┘
│ │ │
│ инструменты │
│ ┌─────────┬───────┬───────┐ │
│ │ файлы │ shell │ веб │ │
│ └─────────┴───────┴───────┘ │
└──────────────────────────────┘

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

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

Цикл агента: что происходит после Enter

Обычный чат устроен так: вопрос — ответ. Агент устроен иначе: вопрос — много шагов — ответ. Эти шаги называют циклом агента.

Разберём на примере. Вы написали: «тест авторизации падает, почини».

  1. Харнес собирает запрос: системные инструкции, описания инструментов, инструкции проекта, вашу фразу. Отправляет модели.
  2. Модель отвечает не текстом, а вызовом инструмента: «запусти тесты авторизации».
  3. Харнес проверяет, можно ли это делать без спроса. Если нельзя — спрашивает вас. Потом запускает команду и получает вывод.
  4. Харнес отправляет модели новый запрос: всё прежнее плюс вывод тестов.
  5. Модель видит ошибку и просит найти в коде функцию, которая упала. Харнес ищет и возвращает результат.
  6. Модель просит прочитать файл. Потом просит заменить в нём одну строку на другую. Потом снова запустить тесты.
  7. Тесты прошли. Модель отвечает обычным текстом: что было не так и что она поправила. Вызовов инструментов в ответе нет — ход закончен.

Документация описывает этот цикл тремя фазами: собрать контекст → действовать → проверить результат. Фазы не идут строго по очереди: что делать дальше, модель решает после каждого шага, глядя на то, что вернул предыдущий.

Три детали, которые стоит знать.

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

Вызовы бывают параллельными. Если модели нужно прочитать пять файлов, она просит все пять в одном ответе, и харнес выполняет их одновременно.

Вмешаться можно в любой момент. Esc останавливает текущий вызов и возвращает управление вам. А если просто напечатать сообщение, пока агент работает, он прочитает его после текущих вызовов, в том же ходе. Это удобный способ поправить курс, не обрывая работу.

Что модель видит в начале сессии

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

ЧтоОткуда берётсяКогда загружается
Системный промптвстроен в Claude Codeвсегда
Описания встроенных инструментоввстроенывсегда
Сведения об окружениирабочая папка, ОС, ветка git, незакоммиченные изменения, последние коммитывсегда
Инструкции проектафайлы CLAUDE.md и правила без привязки к путямвсегда
Авто-памятьначало файла MEMORY.mdвсегда
Список скиловтолько имя и описание каждоговсегда; тело — по вызову
MCP-серверытолько имена инструментов и инструкции серверавсегда; схемы — по требованию
Стиль выводавыбранный output styleесли задан

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

Посмотреть, из чего состоит контекст прямо сейчас, можно командой /context: она рисует сетку и показывает, сколько занимают инструменты, память, скилы и сам разговор.

Инструменты: чем агент работает

Инструментов больше тридцати. Запоминать все не нужно, но основные полезно знать по именам: эти же имена пишутся в правилах разрешений и в хуках.

ГруппаИнструментыСпрашивают разрешение
ФайлыRead, Edit, Write, NotebookEditчтение — нет, правка — да
ПоискGrep, Glob, LSPнет
КомандыBash, PowerShell, Monitorда, кроме заведомо безопасных команд
ВебWebFetch, WebSearchда
АгентыAgent, SendMessage, ListAgents, Workflowв основном нет
ПланированиеEnterPlanMode, ExitPlanMode, TaskCreate и другие, AskUserQuestionнет
РасширенияSkill, ToolSearch, инструменты MCP-серверовзависит от скила и сервера
РасписаниеCronCreate, CronList, CronDelete, ScheduleWakeupнет
Рабочие копииEnterWorktree, ExitWorktreeвход — да

Теперь по порядку о тех, из которых состоит почти вся работа.

Чтение файлов

Все примеры этого раздела сняты с маленького учебного проекта. В нём пять файлов: модуль сессий, два обработчика API, тест и собранный бандл в папке dist, которая внесена в .gitignore.

demo/
├── .gitignore node_modules/ и dist/
├── dist/bundle.js
├── src/
│ ├── auth/session.ts
│ └── api/
│ ├── login.ts
│ └── profile.ts
└── tests/session.test.ts

Вызов инструмента — это JSON с параметрами: именно в таком виде модель его и отправляет, а имя инструмента я подписываю над блоком. Перевод строки внутри значения записывается как \n, это обычное правило JSON. Ответы показаны такими, какими их вернул харнес; длинные абсолютные пути сокращены до относительных.

Read принимает путь к файлу и возвращает его содержимое. У каждой строки слева стоит её номер:

JSON · вызов Read
{
"file_path": "src/auth/session.ts"
}
TypeScript · ответ Read
1 import { db } from '../db';
2
3 const TTL = 60 * 60;
4
5 export function createSession(userId: string) {
6 const token = crypto.randomUUID();
7 db.sessions.insert({ token, userId, expiresAt: Date.now() + TTL * 1000 });
8 return token;
9 }
10
11 export function findSession(token: string) {
12 const session = db.sessions.find(token);
13 if (!session) {
14 return null;
15 }
16 if (session.expiresAt < Date.now()) {
17 return null;
18 }
19 return session;
20 }

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

Большой файл целиком читать незачем. У Read есть два необязательных параметра: с какой строки начать и сколько строк взять. Так агент читает только нужную функцию:

JSON · вызов Read
{
"file_path": "src/auth/session.ts",
"offset": 11,
"limit": 6
}
TypeScript · ответ Read
11 export function findSession(token: string) {
12 const session = db.sessions.find(token);
13 if (!session) {
14 return null;
15 }
16 if (session.expiresAt < Date.now()) {

Обычно это выглядит так: поиск сообщил, что нужное находится в строке 340 файла на две тысячи строк, и агент читает строки с 320 по 380, а не весь файл.

Ограничения такие. За один вызов возвращается до 25 тысяч токенов. Файл больше 256 КБ целиком без явного указания не читается: агент получит отказ и прочитает его частями. Если файла нет, ответ — обычная ошибка, и модель видит её как результат вызова:

ответ Read
File does not exist. Note: your current working directory is D:\projects\demo.

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

Читает Read не только текст. Картинку (PNG, JPEG, GIF, WebP) модель увидит как изображение: так агент смотрит на скриншоты и макеты. PDF читается постранично, блокнот Jupyter — ячейками вместе с выводом. Двоичные форматы вроде .xlsx или .zip инструмент не откроет: для них агент пишет небольшой скрипт.

Редактирование: точная замена строки

Это самая неочевидная часть, и на ней стоит задержаться.

Агент не переписывает файл целиком и не создаёт патч в формате diff. Инструмент Edit принимает три вещи: путь, старый фрагмент и новый фрагмент. Харнес находит в файле старый фрагмент и заменяет его новым.

Самый простой случай — поменять одну строку. Сессия должна жить сутки, а не час:

JSON · вызов Edit
{
"file_path": "src/auth/session.ts",
"old_string": "const TTL = 60 * 60;",
"new_string": "const TTL = 60 * 60 * 24;"
}
ответ Edit
The file src/auth/session.ts has been updated successfully.

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

У этой схемы три правила, и все три — защита от тихой порчи кода. Разберём каждое на примере.

Правило первое: совпадение точное. Никаких регулярных выражений и «примерно похоже». Допустим, модель по памяти решила, что в файле написано const TTL = 3600;:

JSON · вызов Edit
{
"file_path": "src/auth/session.ts",
"old_string": "const TTL = 3600;",
"new_string": "const TTL = 86400;"
}
ответ Edit
String to replace not found in file.
String: const TTL = 3600;

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

Правило второе: фрагмент должен встречаться в файле один раз. В нашем файле строка return null; есть дважды. Попробуем заменить её:

JSON · вызов Edit
{
"file_path": "src/auth/session.ts",
"old_string": " return null;",
"new_string": " return undefined;"
}
ответ Edit
Found 2 matches of the string to replace, but replace_all is false.
To replace all occurrences, set replace_all to true. To replace only one
occurrence, please provide more context to uniquely identify the instance.
String: return null;

Харнес не стал угадывать, какое из двух мест имелось в виду. Дальше у модели два пути.

Если нужно одно конкретное место, она берёт в old_string больше окружающего кода — столько, чтобы фрагмент стал единственным. Например, нужно удалять просроченную сессию перед возвратом. Строку return null; модель захватывает вместе с условием над ней:

JSON · вызов Edit
{
"file_path": "src/auth/session.ts",
"old_string": " if (session.expiresAt < Date.now()) {\n return null;",
"new_string": " if (session.expiresAt < Date.now()) {\n db.sessions.delete(token);\n return null;"
}

Теперь фрагмент из двух строк встречается в файле один раз, и правка проходит. Заметьте, что new_string повторяет неизменённые строки: инструмент не «вставляет строку», он заменяет один кусок текста другим.

Если же нужны все вхождения — например, при переименовании переменной в пределах файла — модель ставит флаг:

JSON · вызов Edit
{
"file_path": "src/auth/session.ts",
"old_string": "session",
"new_string": "userSession",
"replace_all": true
}

Здесь виден и подвох: такая замена затронет и db.sessions, превратив его в db.userSessions. Замена текстовая, о синтаксисе языка она ничего не знает. Поэтому для переименований по всему проекту агент обычно берёт инструмент языкового сервера, а не текстовую замену.

Правило третье: сначала прочитать, потом править. Изначально оно было жёстким: правка файла, который не читался в этом разговоре, отклонялась. Смысл в том, чтобы модель правила то, что реально лежит на диске, а не то, что ей кажется. У новейших моделей требование ослаблено: если содержимое уже известно — из вывода поиска или команды cat — отдельное чтение не обязательно. На более старых моделях оно требуется всегда, а для блокнотов Jupyter и для файлов, прочитанных только частично, — на любых.

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

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

Почему не diff. Формат diff требует от модели точно посчитать номера строк, а в счёте модели ошибаются. Замена «найди этот текст» номеров не требует вообще, и ошибка в ней всегда громкая: либо фрагмент нашёлся ровно один раз, либо правки нет.

Создание и перезапись: Write

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

JSON · вызов Write
{
"file_path": "src/auth/cleanup.ts",
"content": "import { db } from '../db';\n\nexport function removeExpired() {\n db.sessions.deleteWhere((s) => s.expiresAt < Date.now());\n}\n"
}

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

Write остаётся для двух случаев: новый файл и полное переписывание, когда от старого содержимого почти ничего не остаётся.

Удаление, переименование, перенос

Отдельных инструментов для этого нет. Удалить файл, переименовать его или перенести в другую папку агент может только командой оболочки: rm, mv, git mv. Это важно по двум причинам. Такие действия идут через разрешения для команд, а не для правок. И откат по чекпоинтам их не видит — об этом в разделе про откат.

Что вы видите в интерфейсе

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

Если открыта IDE с расширением, diff показывается в окне редактора, а не в терминале.

А перед каждой правкой харнес сохраняет прежнюю версию файла — об этом в разделе про откат.

Поиск: индекса нет

Многие ждут, что агент при первом запуске «индексирует проект»: строит базу эмбеддингов или граф кода, как это делают некоторые редакторы. Claude Code этого не делает. Постоянного индекса у него нет.

Вместо этого агент ищет так же, как искал бы человек в терминале, только быстрее и настойчивее:

Инструментов поиска два: один ищет файлы по имени, другой — по содержимому.

Glob — поиск по имени. Принимает маску пути и возвращает список файлов:

JSON · вызов Glob
{
"pattern": "**/*.ts"
}
ответ Glob
src/auth/session.ts
src/api/login.ts
src/api/profile.ts
tests/session.test.ts

Две звёздочки означают «любая глубина вложенности». Результат отсортирован по времени изменения, и выдаётся не больше ста файлов. Типичные маски: src/**/*.test.ts — все тесты, **/package.json — все пакеты монорепозитория, **/*config* — всё, что похоже на конфигурацию.

Grep — поиск по содержимому. Принимает регулярное выражение. Внутри это ripgrep, очень быстрая утилита поиска. У него три режима, и агент выбирает их по очереди, от дешёвого к подробному.

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

JSON · вызов Grep
{
"pattern": "findSession"
}
ответ Grep
Found 3 files
tests/session.test.ts
src/api/profile.ts
src/auth/session.ts

Обратите внимание: в папке dist лежит бандл, где это слово тоже есть, но в выдачу он не попал. Папка внесена в .gitignore, а Grep игнорируемые файлы пропускает.

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

JSON · вызов Grep
{
"pattern": "findSession\\(",
"glob": "src/**/*.ts",
"output_mode": "content",
"-C": 1
}
ответ Grep
src/api/profile.ts-3-export function profile(token: string) {
src/api/profile.ts:4: const session = findSession(token);
src/api/profile.ts-5- return session ? { userId: session.userId } : null;
--
src/auth/session.ts-10-
src/auth/session.ts:11:export function findSession(token: string) {
src/auth/session.ts-12- const session = db.sessions.find(token);

Строка с двоеточиями — совпадение, строки с дефисами — контекст вокруг. Параметр -C: 1 означает одну строку до и одну после. Этого часто хватает, чтобы понять место, не открывая файл.

Третий режим — количество. Вопрос «сколько раз это встречается»:

JSON · вызов Grep
{
"pattern": "return null",
"output_mode": "count"
}
ответ Grep
src/auth/session.ts:2
Found 2 total occurrences across 1 file.

Так агент оценивает масштаб до начала работы: одно дело поправить два места, другое — двести.

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

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

Две детали, которые экономят время, когда агент «не находит очевидное»:

  • Grep пропускает файлы из .gitignore. Glob по умолчанию не пропускает. Поэтому файл из игнорируемой папки находится по имени, но не по содержимому.
  • На macOS, Linux и в WSL отдельных инструментов Grep и Glob в наборе нет: там агент пользуется командами find и grep через shell, а Claude Code подставляет под них встроенные быстрые реализации. На Windows это отдельные инструменты. Поведение одно, названия в логах разные.

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

Команды: Bash и PowerShell

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

Как он себя ведёт:

  • Каждая команда — отдельный процесс. Переменные окружения из одной команды в следующую не переходят. Рабочая папка переходит, пока вы внутри проекта; вышли за его пределы — следующая команда снова стартует из проекта.
  • Ваш профиль подхватывается. При старте сессии Claude Code снимает слепок вашей оболочки — алиасы, функции, настройки — и применяет его к командам.
  • Есть таймаут. По умолчанию две минуты, модель может попросить до десяти.
  • Длинное уходит в фон. Сборку или сервер агент запускает в фоне и продолжает работать; когда процесс завершится, харнес сообщит ему об этом. Команда, которая не уложилась в таймаут, тоже переезжает в фон сама.
  • Вывод обрезается. Модели сразу достаётся около 30 тысяч символов. Остальное сохраняется в файл, и агент читает из него нужные куски. Так лог сборки на мегабайт не съедает контекст.

Пара примеров. Вот как выглядит правило про рабочую папку. Агент перешёл во временный каталог за пределами проекта и выполнил там команду:

JSON · вызов Bash
{
"command": "cd /tmp/build && ls"
}
ответ Bash
bundle.js
Shell cwd was reset to D:\projects\demo

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

А вот запуск в фоне. Сервер разработки не завершается сам, поэтому ждать его конца бессмысленно:

JSON · вызов Bash
{
"command": "npm run dev",
"run_in_background": true
}

Харнес сразу возвращает управление и идентификатор фоновой задачи. Вывод сервера пишется в файл, и агент читает его обычным Read, когда нужно посмотреть, что там произошло. Список фоновых задач показывает команда /tasks; там же их можно остановить.

На Windows Bash — это Git Bash из Git for Windows. Рядом работает инструмент PowerShell; без установленного Git он остаётся единственной оболочкой. Отсюда типичная путаница: синтаксис у них разный, и команда, написанная для одного, в другом не работает.

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

Команду можно выполнить и самому, не выходя из сессии: строка, начатая с !, запускается в оболочке, а её вывод попадает в разговор.

Веб

WebSearch возвращает заголовки и адреса из поискового бэкенда Anthropic. Сами страницы он не скачивает.

WebFetch скачивает страницу, но работает хитрее, чем кажется. Он превращает HTML в Markdown и отдаёт его другому, отдельному запросу к небольшой модели вместе с вопросом. Основной агент получает уже ответ на вопрос, а не сырую страницу. Смысла два: большая страница не забивает контекст, и вредные инструкции, спрятанные в тексте страницы, не попадают основному агенту напрямую. Оборотная сторона: это пересказ, и точные цифры из таблицы он иногда путает. Когда нужна дословная точность, агенту лучше скачать страницу командой curl.

Для сайтов, которым нужен вход или JavaScript, эти два инструмента не годятся. Там нужен настоящий браузер — о вариантах ниже.

Одна задача целиком

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

ШагВызовЗачемЧто вернулось
1Grep по слову TTLнайти, где задан срок жизниодин файл: модуль сессий
2Read этого файлаувидеть код целиком, он короткийдвадцать строк с номерами
3Grep по findSessionпонять, кого заденет изменениетри файла: сам модуль, обработчик профиля, тест
4Read обработчика и теста, двумя вызовами сразупроверить, что они ждут от функцииоба файла
5Edit: строка с TTLсутки вместо часа«updated successfully»
6Edit: условие с просроченной сессиейдобавить удаление«updated successfully»
7Bash: запуск тестовпроверить результатвывод тестов
8ответ текстомрассказать, что сделано—

На что здесь стоит посмотреть.

Агент начал с поиска, а не с чтения всего подряд. В проекте на тысячу файлов он точно так же прочитал бы три.

Шаг 3 сделан до правки. Прежде чем менять поведение функции, агент выяснил, кто ею пользуется. Если бы обработчик профиля полагался на то, что просроченная сессия остаётся в базе, это выяснилось бы здесь, а не после.

На шаге 4 два вызова ушли одним ответом. Чтения друг от друга не зависят, и харнес выполнил их одновременно.

На шаге 6 пришлось взять две строки. Одна строка return null; в файле не уникальна — это тот самый случай из раздела про правку.

Шаг 7 замыкает цикл. Без него агент остановился бы на «выглядит правильно». С ним — на «тесты прошли». Если бы тест упал, вывод вернулся бы модели, и цикл пошёл бы дальше: прочитать ошибку, поправить, запустить снова.

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

Контекст: окно, сжатие и цена

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

У нынешних моделей окно — миллион токенов. Этого хватает на часы работы, и упереться в предел трудно. Но окно всё равно наполняется, и тогда срабатывает сжатие (compaction): Claude Code просит модель пересказать разговор и заменяет историю этим пересказом. Работа продолжается, но с краткой версией прошлого.

Здесь важно знать, что сжатие переживает, а что нет.

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

Практический вывод простой. Всё, что должно действовать всю сессию, должно лежать в файле, а не в чате. Сказанное в чате может не пережить сжатия; записанное в инструкции проекта перечитается с диска.

Управляют этим четыре команды: /context показывает, чем занято окно; /compact сжимает сейчас, и ему можно подсказать, что сохранить; /clear начинает разговор с чистого листа, старый остаётся на диске; /autocompact задаёт порог, при котором сжатие включается само.

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

Сессии: где хранится разговор и как откатиться

Сессия — это один разговор. Харнес записывает его на диск по мере работы, в обычный текстовый файл формата JSONL: одна строка — одна запись в JSON.

Лежит он в домашней папке, в каталоге по имени проекта:

~/.claude/projects/D--PycharmProjects-My-Site-on-Astro/
├── 4e5a5be5-….jsonl разговор: сообщения, вызовы инструментов, результаты
├── 4e5a5be5-…/
│ ├── subagents/ разговоры субагентов этой сессии
│ └── tool-results/ большие выводы инструментов, не поместившиеся в запрос
└── memory/ авто-память проекта

Имя папки — это путь к проекту, в котором всё, кроме букв и цифр, заменено дефисами. Так D:\PycharmProjects\My_Site_on_Astro превращается в D--PycharmProjects-My-Site-on-Astro.

Вот как выглядит одна запись — ваше сообщение. Я оставил главные поля и разбил строку для читаемости; в файле это одна строка:

JSON
{
"type": "user",
"uuid": "0b6f2c1e-…",
"parentUuid": "9d41a7f3-…",
"sessionId": "4e5a5be5-…",
"timestamp": "2026-11-19T08:55:12.431Z",
"cwd": "D:\\projects\\demo",
"gitBranch": "master",
"version": "2.1.328",
"message": {
"role": "user",
"content": "сделай, чтобы сессия жила сутки"
}
}

Поле parentUuid связывает запись с предыдущей. Благодаря этому разговор — не просто список, а дерево: когда вы откатываетесь и идёте другим путём, старая ветка остаётся в файле, а новая растёт от той же точки. Запись ответа модели устроена так же, только в message лежат блоки: размышление, текст, вызовы инструментов, а рядом — сведения о модели и расходе токенов.

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

Хранятся сессии 30 дней, потом удаляются сами; срок меняется настройкой cleanupPeriodDays. Удалить всё, что Claude Code знает об одном проекте, можно командой claude purge.

Что с сессиями можно делать:

  • Продолжить. claude --continue открывает последнюю сессию в этой папке, claude --resume показывает список. Внутри сессии то же делает /resume.
  • Ответвить. /branch копирует разговор в новую сессию с текущего места, оригинал не меняется. Удобно попробовать другой путь.
  • Назвать. /rename или флаг --name: по имени сессию потом проще найти.

Откат: чекпоинты

Перед каждой правкой файла харнес сохраняет его прежнюю версию. Эти копии лежат в ~/.claude/file-history/, по папке на сессию. Каждое ваше сообщение создаёт контрольную точку.

Команда /rewind (или Esc дважды на пустой строке) открывает список точек. Для выбранной можно вернуть код, вернуть разговор или и то и другое. Там же есть «сжать начиная отсюда»: файлы не трогаются, а хвост разговора заменяется пересказом.

У отката есть граница, о которой надо помнить. Он знает только про правки, сделанные инструментами Edit и Write. То, что сделала команда оболочки, он не откатит: удалённый через rm файл, миграцию базы, git push, установленный пакет. Не отслеживаются и правки субагентов, и ваши собственные правки в редакторе. Чекпоинты — это страховка внутри сессии, а не замена git.

Папка проекта: что лежит в .claude

Теперь о том, чем Claude Code настраивается под конкретный проект. Почти всё живёт в папке .claude в корне репозитория и коммитится вместе с кодом, чтобы у всей команды агент вёл себя одинаково.

проект/
├── CLAUDE.md инструкции проекта, читаются в каждой сессии
├── CLAUDE.local.md личные инструкции, в git не идут
├── .mcp.json MCP-серверы проекта
├── .worktreeinclude какие файлы вне git копировать в рабочие копии
└── .claude/
├── settings.json настройки команды: разрешения, хуки, переменные
├── settings.local.json личные настройки, в git не идут
├── rules/ правила, по файлу на тему
├── skills/<имя>/SKILL.md скилы
├── agents/ описания субагентов
├── commands/ команды в старом формате
├── output-styles/ стили вывода
├── workflows/ сохранённые сценарии с несколькими агентами
├── agent-memory/ память субагентов
├── hooks/ обычно здесь держат скрипты хуков
└── worktrees/ отдельные рабочие копии для параллельных сессий

Ниже — про каждую часть: что это, когда загружается и чем отличается от соседних.

Инструкции: CLAUDE.md

CLAUDE.md — это текстовый файл с тем, что агент должен знать в каждой сессии: как собрать проект, как запустить тесты, какие здесь есть неочевидные договорённости. Создать первую версию помогает команда /init.

Файлов может быть несколько, и они складываются. Порядок загрузки такой:

УровеньГде лежитДля чего
Организациясистемная папка: C:\Program Files\ClaudeCode\, /etc/claude-code/, /Library/Application Support/ClaudeCode/правила компании, задаёт администратор
Личный~/.claude/CLAUDE.mdваши привычки во всех проектах
ПроектCLAUDE.md в корне или .claude/CLAUDE.mdобщие правила проекта, в git
Личный в проектеCLAUDE.local.mdваши заметки по этому проекту, не в git

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

Внутри можно подключать другие файлы строкой @путь/к/файлу. Вложенность — до четырёх уровней.

Про AGENTS.md. Это общий формат инструкций, который читают многие агенты. Claude Code читает его, только если в проекте нет своего CLAUDE.md. Поведение меняется в настройках: можно читать оба.

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

Правила: .claude/rules/

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

Интереснее правило с шапкой, где указаны маски путей:

Markdown · .claude/rules/api-endpoints.md
---
paths:
- "src/api/**/*.ts"
---
# Правила для API
- Каждый эндпоинт валидирует вход.
- Ошибки отдаются в общем формате.

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

Личные правила на все проекты кладутся в ~/.claude/rules/.

Авто-память

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

Хранится она не в проекте, а в домашней папке: ~/.claude/projects/<проект>/memory/. Внутри — индексный файл MEMORY.md и отдельные файлы по темам. В начале сессии в контекст попадает только начало индекса, первые двести строк. Тематические файлы агент открывает, когда они нужны.

Индекс — это просто список ссылок, по строке на заметку:

Markdown · memory/MEMORY.md
- [Тесты только через контейнер](tests-in-docker.md) — локальный запуск тестов падает, нужна база из docker compose
- [Панель мониторинга](grafana-dashboard.md) — где смотреть задержки API после выкладки

А сама заметка — файл с короткой шапкой и одним фактом:

Markdown · memory/tests-in-docker.md
---
name: tests-in-docker
description: Интеграционные тесты запускать только в контейнере, локально они падают
metadata:
type: feedback
---
Интеграционные тесты запускать командой `docker compose run tests`.
**Почему:** тестам нужна база определённой версии, локально её нет.
**Как применять:** перед запуском тестов не пробовать `npm test` напрямую.

Типов заметок четыре: о пользователе, о его замечаниях к работе, о проекте и ссылки на внешние ресурсы. По описанию в шапке агент решает, открывать ли файл.

Что из этого следует:

  • Память локальна для машины и для вас. Коллега её не получит, на другом компьютере её нет. Всё, что должны знать все, — в правила проекта.
  • Это обычные Markdown-файлы. Их можно читать и править руками; командой /memory — посмотреть и выключить.
  • Проект определяется по git-репозиторию, поэтому у всех рабочих копий одного репозитория память общая.
  • Чистка по сроку хранения её не трогает.

Чтобы не путать, чем отличаются три вида «памяти»:

Кто пишетГде лежитВидит командаКогда в контексте
CLAUDE.md и правилавыв репозиториидавсегда или по маске путей
Авто-памятьагентв домашней папкенетиндекс — всегда, темы — по требованию
История сессиихарнесв домашней папкенеттолько в этой сессии

Скилы: знание по требованию

Скил — это папка с файлом SKILL.md: инструкция, как делать определённую работу. Например, как выкладывать релиз или как читать данные из аналитики. Рядом могут лежать вспомогательные файлы и скрипты.

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

Markdown · .claude/skills/release/SKILL.md
---
name: release
description: Выпуск новой версии. Использовать, когда просят выпустить релиз или поднять версию.
disable-model-invocation: true
allowed-tools: Bash(npm version *), Bash(git tag *)
---
1. Убедиться, что рабочее дерево чистое.
2. Поднять версию: `npm version $ARGUMENTS`.
3. Собрать проект и прогнать тесты.

Что здесь важно:

  • description — это то, по чему агент решает, подходит ли скил. Описание важнее тела: плохо описанный скил не будет вызван.
  • disable-model-invocation: true запрещает агенту запускать скил самому. Остаётся ручной вызов командой /release 1.4.0. Так помечают процедуры с последствиями.
  • $ARGUMENTS заменяется на то, что вы написали после имени команды.
  • allowed-tools заранее разрешает перечисленные инструменты на время работы скила.

Ещё скил можно запустить в отдельном контексте (context: fork): тогда он выполняется как субагент и возвращает только результат.

Скилы и слэш-команды — это одно и то же. Любой скил вызывается как /имя. Старый формат, файлы в .claude/commands/, по-прежнему работает. Скилы бывают личные (~/.claude/skills/), проектные, из плагинов и встроенные: /code-review, /simplify, /doctor, /loop, /run и другие.

Места в контексте под список скилов отведено немного — около одного процента окна. Когда скилов много, у редко используемых остаётся только имя. Посмотреть, сколько стоит каждый, можно в /skills.

Субагенты

Субагент — это отдельный экземпляр агента со своим чистым контекстом. Главный агент даёт ему задачу, субагент работает в собственном цикле и возвращает один итоговый отчёт.

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

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

Встроенных субагентов несколько:

ИмяЧто делает
Exploreтолько чтение: быстрый поиск по кодовой базе
Planтолько чтение: готовит план реализации
general-purposeвсе инструменты, для многошаговых задач
claude-code-guideотвечает на вопросы о самом Claude Code

Своих описывают файлами в .claude/agents/ или ~/.claude/agents/:

Markdown · .claude/agents/test-runner.md
---
name: test-runner
description: Запускает тесты и разбирает падения. Использовать после изменений в коде.
tools: Read, Grep, Glob, Bash
model: haiku
---
Запусти тесты, найди причину каждого падения и верни короткий список:
тест, причина, файл и строка.

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

Полезные возможности:

  • Фон. Субагент может работать в фоне, пока главный агент занят другим; результат придёт уведомлением.
  • Изоляция. С isolation: worktree субагент получает собственную копию репозитория и не мешает правкам в основной.
  • Форк. Обычный субагент начинает с чистого листа. Форк наследует весь разговор; его запускает /subtask.
  • Своя память. С полем memory у субагента появляется папка заметок, которая переживает сессии.
  • Вложенность. Субагент может запустить своего субагента, до трёх уровней вглубь.

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

Хуки

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

Моментов, на которые можно повесить хук, больше тридцати: старт сессии, отправка сообщения, перед вызовом инструмента и после него, запрос разрешения, конец хода, сжатие контекста и так далее. Хук получает на вход JSON с описанием события и может не только что-то сделать, но и повлиять на ход: запретить вызов инструмента, добавить текст в контекст, вернуть агента к работе.

JSON · .claude/settings.json
{
"hooks": {
"PostToolUse": [
{
"matcher": "Edit|Write",
"hooks": [{ "type": "command", "command": "npm run lint" }]
}
]
}
}

Этот хук запускает линтер после каждой правки файла. Модель об этом не просили — это делает харнес.

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

MCP: внешние инструменты

Встроенных инструментов хватает для работы с файлами и терминалом. Но агенту бывает нужно и другое: заглянуть в трекер задач, в базу данных, в документацию библиотеки. Для этого есть MCP (Model Context Protocol) — стандарт, по которому внешняя программа-сервер объявляет свои инструменты, а агент их вызывает. Как устроен сам протокол, я писал в отдельной статье.

Для Claude Code MCP-сервер — это просто ещё один набор инструментов. Подключается он командой или файлом:

JSON · .mcp.json
{
"mcpServers": {
"docs": {
"type": "http",
"url": "https://mcp.example.com/mcp"
},
"local-db": {
"command": "npx",
"args": ["-y", "example-db-mcp"],
"env": { "DB_URL": "${DB_URL}" }
}
}
}

Первый сервер удалённый, к нему агент ходит по HTTP. Второй локальный: Claude Code сам запускает его как процесс и общается с ним через стандартный ввод и вывод.

То же самое делается командами, без правки файла руками:

Shell
claude mcp add --transport http docs https://mcp.example.com/mcp
claude mcp add local-db -e DB_URL=postgres://localhost/app -- npx -y example-db-mcp
claude mcp add --scope project --transport http docs https://mcp.example.com/mcp

Первая команда добавляет удалённый сервер. Вторая — локальный: всё, что после двух дефисов, — это команда его запуска. Третья отличается флагом --scope: он решает, кому сервер будет виден.

Инструменты сервера получают имена вида mcp__<сервер>__<инструмент>, например mcp__docs__search. Под этими именами они фигурируют в правилах разрешений и в хуках.

Сервер можно подключить на трёх уровнях, и от уровня зависит, где хранится запись:

УровеньКому виденГде записан
local (по умолчанию)вам, в этом проекте~/.claude.json, в разделе проекта
projectвсей команде.mcp.json в корне репозитория
userвам, во всех проектах~/.claude.json

Серверы из .mcp.json требуют одноразового подтверждения: чужой репозиторий не должен молча запускать программы на вашей машине.

Важная деталь про контекст. Раньше каждый сервер сразу выкладывал в контекст полные описания всех своих инструментов, и пять серверов могли съесть десятки тысяч токенов. Теперь описания отложены: в контексте только имена. Когда инструмент понадобился, агент вызывает ToolSearch и получает его полную схему. Поэтому много подключённых серверов больше не проблема.

И ещё одно: если вы вошли через аккаунт claude.ai, коннекторы, подключённые там (почта, календарь, диск), доступны и в Claude Code.

Плагины, маркетплейсы и моды

Плагин — это упаковка. В одну папку собираются скилы, субагенты, хуки, MCP-серверы, стили вывода, темы, исполняемые файлы, и всё это ставится одной командой. Так делятся настройками между проектами и командами.

Источник плагинов называется маркетплейсом. Это git-репозиторий или адрес с файлом-каталогом. Официальный маркетплейс Anthropic подключается сам при первом запуске. Управление — командой /plugin: посмотреть доступные, поставить, включить, выключить.

Два вида плагинов стоит выделить.

Плагины языковых серверов. Они дают агенту инструмент LSP, о котором шла речь в разделе про поиск. Есть готовые для полутора десятков языков, от TypeScript и Python до Kotlin и Rust. Сам языковой сервер должен быть установлен в системе.

Моды. Обычный плагин добавляет агенту знания и инструменты. Мод меняет сам Claude Code: его код работает внутри программы. Мод может нарисовать панель рядом с чатом или полосу над полем ввода, добавить команду, которая выполняется мгновенно, без обращения к модели, вмешаться в вызов инструмента. Моды появились в версии 2.1.287. Написать свой можно, просто попросив агента.

К модам стоит относиться как к любой программе, которую вы запускаете: код мода работает с вашими правами и вне песочницы. Если после установки что-то сломалось, claude --safe-mode запустит сессию без всех настроек, плагинов и хуков.

Стили вывода, строка состояния, клавиши

Три небольшие настройки интерфейса.

Стиль вывода меняет манеру ответов. Встроенные: обычный, краткий, объясняющий (добавляет пояснения, почему сделано так) и обучающий (оставляет вам куски для самостоятельной работы). Свои кладутся файлами в output-styles/.

Строка состояния — нижняя строка интерфейса. Её рисует ваш скрипт: харнес передаёт ему JSON с данными сессии, а то, что скрипт напечатает, появляется на экране. Туда выводят ветку git, модель, заполненность контекста, расход лимита.

Клавиши переназначаются в файле ~/.claude/keybindings.json.

Настройки: где лежат и кто главнее

Настройки хранятся в файлах settings.json. Их несколько, и одна и та же настройка может быть задана в нескольких. Побеждает уровень с более высоким приоритетом.

ПриоритетУровеньФайл
1, высшийОрганизацияmanaged-settings.json в системной папке, политика ОС или настройки с сервера
2Запускфлаг --settings
3Личные в проекте.claude/settings.local.json
4Проект.claude/settings.json
5Личные~/.claude/settings.json

Списки не перекрываются, а складываются. Правила разрешений из личного файла и из файла проекта действуют вместе.

Есть ещё один файл, который постоянно путают с настройками: ~/.claude.json. Он лежит не в папке .claude, а рядом с ней, в домашнем каталоге. Это не настройки, а состояние: в какой аккаунт вы вошли, каким папкам доверяете, личные MCP-серверы, счётчики подсказок, кэши. Claude Code пишет в него сам. Руками его трогать обычно незачем.

Третий механизм — переменные окружения. Через них задают ключ API, провайдера, модель, таймауты. Их можно выставить в оболочке или в блоке env файла настроек.

Проверить, что на самом деле загрузилось, помогают две команды: /status показывает источники настроек, /doctor находит битые файлы и противоречия. Полный список ключей с примерами — в справочнике.

Что лежит на диске за пределами проекта

Проект — только часть картины. Большая часть данных Claude Code живёт в домашней папке пользователя. На Windows это C:\Users\<имя>\.claude, на macOS и Linux — ~/.claude.

Вот что там лежит. Часть папок появляется, только когда вы начинаете пользоваться соответствующей возможностью.

~/.claude/
├── settings.json личные настройки
├── CLAUDE.md личные инструкции на все проекты
├── keybindings.json свои сочетания клавиш
├── rules/ skills/ agents/ commands/ output-styles/ workflows/ themes/
│ личные правила, скилы, субагенты и прочее
├── .credentials.json данные входа в аккаунт
├── history.jsonl история введённых вами сообщений
├── projects/ разговоры и авто-память, по папке на проект
├── file-history/ копии файлов для отката
├── sessions/ по маленькому файлу на каждую запущенную сессию
├── session-env/ окружение сессий
├── shell-snapshots/ слепки настроек оболочки
├── paste-cache/ большие вставки из буфера
├── plans/ планы из режима планирования
├── tasks/ списки задач
├── plugins/ установленные плагины и маркетплейсы
├── daemon/ jobs/ состояние фоновых сессий
├── ide/ связь с запущенными IDE
├── chrome/ мост к расширению в браузере
├── debug/ отладочные логи
├── backups/ копии файла ~/.claude.json
├── cache/ каталог моделей, список изменений
├── agent-memory/ память личных субагентов
└── teams/ почтовые ящики команд агентов

Разберём то, что важно понимать.

projects/ — самая большая и самая ценная папка. Здесь все ваши разговоры и вся авто-память. У меня в ней несколько десятков подпапок, по одной на каждый проект, где я хоть раз запускал Claude Code. Если переносите работу на другой компьютер, копировать надо её.

.credentials.json — данные входа. На Windows и Linux это файл, защищённый правами доступа к профилю пользователя. На macOS данные входа лежат в системной связке ключей, а файл используется как запасной вариант. Этот файл нельзя коммитить, пересылать и показывать.

history.jsonl — то, что вы набирали в поле ввода. Из него работают стрелка вверх и поиск по Ctrl+R. По сроку хранения не удаляется.

sessions/ — служебные файлы работающих сессий: номер процесса, рабочая папка, имя, статус. По ним сессии находят друг друга и по ним же Claude Code понимает, что сессия упала.

file-history/ — копии файлов перед правками. Версии называются по хэшу пути с номером: первая правка, вторая, третья.

shell-snapshots/ — слепки алиасов и функций вашей оболочки. Из-за них команды агента ведут себя как ваши.

ide/ — файлы-замки с портом, на котором слушает расширение в VS Code или JetBrains. Через них терминальная сессия находит открытый редактор.

Чистка работает так: разговоры, копии файлов, планы, логи и вставки удаляются, когда становятся старше срока хранения, по умолчанию 30 дней. Авто-память, история ввода и настройки не удаляются.

Теперь то, что лежит вне ~/.claude:

ЧтоГде на WindowsГде на macOS и Linux
Состояние и личные MCP-серверыC:\Users\<имя>\.claude.json~/.claude.json
Сама программаC:\Users\<имя>\.local\bin\claude.exe~/.local/bin/claude
Временные файлы сессии%TEMP%\claude\<проект>\<сессия>\временная папка системы
Настройки организацииC:\Program Files\ClaudeCode\/etc/claude-code/, /Library/Application Support/ClaudeCode/
Мост к браузеру%APPDATA%\Claude Code\ChromeNativeHostпапка настроек браузера
Кэш%LOCALAPPDATA%\claude-cli-nodejs\папка кэша пользователя

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

Всё, что хранится в ~/.claude, можно перенести в другое место переменной CLAUDE_CONFIG_DIR. Это же способ держать на одной машине два аккаунта: у каждого своя папка конфигурации.

Разрешения: что агенту можно без спроса

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

Режимы

Режим определяет поведение по умолчанию. Переключается сочетанием Shift+Tab прямо во время работы.

РежимЧто делает без вопросов
Ручной (default)только читает; на правки и команды спрашивает
acceptEditsплюс правит файлы и выполняет простые файловые команды в рабочей папке
planчитает и исследует, пишет план; исходники не трогает
autoвсё, но каждое действие проверяет фоновый классификатор
dontAskто, что разрешено правилами; всё остальное молча отклоняет
bypassPermissionsвсё без вопросов; правила запрета остаются в силе

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

Правила

Поверх режима действуют правила трёх видов: разрешить, спросить, запретить.

JSON · .claude/settings.json
{
"permissions": {
"allow": ["Bash(npm run *)", "Edit(src/**)"],
"ask": ["Bash(git push *)"],
"deny": ["Read(./.env)", "Read(./secrets/**)"]
}
}

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

Примеры правил и того, что они значат:

ПравилоЧто покрывает
Bash(npm run build)ровно эту команду
Bash(npm run *)любую команду, начинающуюся с npm run
Bash(git log *)git log с любыми аргументами, но не git push
Edit(src/**)правку любых файлов внутри src
Read(./.env)чтение файла .env в корне проекта
Read(~/.ssh/**)чтение чего угодно в папке ключей
WebFetch(domain:docs.example.com)загрузку страниц с этого домена
mcp__docs__*все инструменты MCP-сервера docs
Agent(Explore)запуск субагента Explore
Bashинструмент целиком

Как это работает на живом примере. Агент хочет выполнить npm run test && git push origin main. Харнес делит команду на две части. Первая подходит под разрешение Bash(npm run *). Вторая подходит под правило «спросить» Bash(git push *). Итог: вопрос вам, и в вопросе видна вся команда целиком.

Когда вы в диалоге выбираете «больше не спрашивать», харнес сам дописывает правило в личные настройки проекта, .claude/settings.local.json. Посмотреть и почистить накопившееся можно командой /permissions.

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

Несколько вещей, которые делают правила надёжнее, чем кажется:

  • Составная команда разбирается на части. npm test && rm -rf build проверяется как две команды, и разрешены должны быть обе.
  • Обёртки вроде timeout или nohup отбрасываются перед проверкой.
  • Перенаправление вывода в файл проверяется как правка этого файла.

И одна вещь, из-за которой на правила для команд нельзя полагаться как на стену: одно и то же можно выполнить многими способами. Запрет Bash(curl *) не поймает /usr/bin/curl или скрипт на Python, который делает тот же запрос. Запреты на команды защищают от случайностей, а не от целенаправленного обхода. Настоящую границу ставит песочница.

Доверие папке и защищённые пути

При первом запуске в новой папке Claude Code спрашивает, доверяете ли вы ей. Это не формальность. Файлы проекта могут содержать хуки и MCP-серверы, то есть код, который выполнится на вашей машине. До подтверждения разрешающие правила из проекта не применяются. Чужой репозиторий стоит сначала посмотреть глазами.

Кроме того, есть защищённые пути, запись в которые требует подтверждения даже в режиме автоматических правок: папки .git, .vscode, .idea, .claude, файлы настроек оболочки, .mcp.json. Изменив их, можно заставить выполниться произвольный код, поэтому харнес бережёт их отдельно.

Авто-режим

Ручной режим безопасен, но утомителен: на сотом подтверждении человек перестаёт читать, что подтверждает. Авто-режим решает это иначе. Вопросов нет, но каждое действие, которое не разрешено правилами явно, проверяет отдельная модель-классификатор.

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

Что она блокирует по умолчанию: скачать и сразу выполнить скрипт из сети, отправить секреты наружу, выкатить в продакшен, удалить данные в облаке, выдать права доступа, сделать git push --force или git reset --hard. Что пропускает: работу с файлами в проекте, установку объявленных зависимостей, запросы на чтение, обычный push в ветку.

Если классификатор заблокировал три действия подряд, авто-режим приостанавливается и возвращаются обычные вопросы.

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

JSON · ~/.claude/settings.json
{
"autoMode": {
"environment": [
"$defaults",
"Репозитории организации example-org на GitHub — свои",
"Бакет example-staging — тестовый, писать в него можно"
],
"hard_deny": [
"$defaults",
"Любые изменения в продакшен-базе данных"
]
}
}

Это не шаблоны, а предложения на человеческом языке: их читает модель-классификатор. Строка "$defaults" сохраняет встроенные правила, без неё ваш список заменил бы их. Из настроек проекта этот блок не читается — иначе чужой репозиторий мог бы разрешить себе что угодно.

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

Песочница и изоляция

Разрешения решают, что агент попросит сделать. Изоляция решает, что он сможет сделать, даже если что-то пошло не так. Вариантов несколько, от лёгкого к строгому.

Песочница для команд

Песочница — это ограничение на уровне операционной системы для команд, которые запускает агент. Команда и все процессы, которые она породит, получают урезанный доступ:

  • Запись — только в рабочую папку и временную директорию.
  • Сеть — прямого выхода нет. Весь трафик идёт через локальный прокси, который пропускает только разрешённые домены.
  • Чтение — по умолчанию почти весь диск. Папки с ключами надо закрывать явно.
JSON · .claude/settings.json
{
"sandbox": {
"enabled": true,
"network": {
"allowedDomains": ["registry.npmjs.org", "*.githubusercontent.com"]
},
"filesystem": {
"denyRead": ["~/.ssh", "~/.aws"]
}
}
}

На macOS песочница построена на системном механизме Seatbelt, на Linux и в WSL2 — на bubblewrap. На Windows без WSL песочницы нет: команды выполняются как обычно. Если она вам нужна на Windows, запускайте Claude Code внутри WSL2.

По умолчанию песочница выключена; включается командой /sandbox. У неё приятный побочный эффект: раз команда не может ничего испортить за пределами проекта, её можно выполнять без вопроса. Подтверждений становится заметно меньше.

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

Отдельные рабочие копии

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

Решение — git worktree. Это штатная возможность git: вторая рабочая папка того же репозитория на своей ветке. История общая, файлы раздельные.

Shell
claude --worktree feature-auth

Команда создаёт рабочую копию в .claude/worktrees/feature-auth/ на новой ветке и запускает сессию в ней. Фоновые сессии и субагенты с изоляцией делают то же автоматически. Копия без изменений удаляется при выходе сама.

Одна практическая деталь: файлы, которых нет в git, в новую копию не попадают. Если проекту нужен .env, перечислите его в файле .worktreeinclude, и он будет скопирован.

Важно не путать: worktree защищает ваши файлы от других агентов, а не машину от агента. Это изоляция работы, а не безопасность.

Контейнер и виртуальная машина

Самая надёжная изоляция — запустить агента там, где нечего портить.

Dev-контейнер. У Anthropic есть готовая конфигурация: контейнер с Claude Code и сетевым экраном, который пропускает только нужные адреса. Внутри можно включить режим без вопросов, потому что агенту доступен только смонтированный проект.

Виртуальная машина. То же, но граница ещё жёстче. Об этом варианте подробно ниже, в разделе про удалённую работу.

Облачная сессия. Anthropic запускает агента на своей виртуальной машине. Ваш компьютер не участвует вовсе.

Сводка, чтобы выбирать:

СпособОт чего защищаетЧего не закрывает
Правила разрешенийот случайных действийобходятся другим способом сделать то же
Авто-режимот явно опасных действий без вопросовне является границей безопасности
Песочницакоманды не выйдут за проект и разрешённые доменыинструменты файлов, MCP, хуки; нет на Windows без WSL
Worktreeсессии не мешают друг другуне защищает машину
Контейнер, ВМагент не видит вашу системуто, что вы сами туда смонтировали и какие ключи дали

Модели, усилие и размышление

Харнес один, а моделей за ним несколько, и у каждой есть ручки.

Модель выбирается командой /model или флагом --model. Обычно пишут не полный идентификатор, а короткое имя семейства: fable, opus, sonnet, haiku. За коротким именем всегда стоит самая свежая модель семейства. Старшие модели умнее и дороже, младшие быстрее и дешевле. Есть и составной вариант opusplan: старшая модель планирует, средняя исполняет.

Усилие (effort) — это то, сколько модель думает и проверяет, прежде чем ответить. Уровней пять: low, medium, high, xhigh, max. Низкий годится для мелких понятных правок, высокий — когда важна проверка, максимальный — для по-настоящему трудных задач, с убывающей отдачей. Задаётся командой /effort. Усилие влияет и на скорость, и на расход: на max та же задача может стоить в разы больше, чем на medium.

Размышление (thinking) — это рассуждения модели перед ответом, которые вы видите свёрнутыми. У нынешних моделей оно адаптивное: модель сама решает, где подумать подольше. Слово ultrathink в сообщении поднимает усилие на один этот ход.

Быстрый режим (/fast) — та же модель, но ответ идёт примерно в два с половиной раза быстрее и стоит дороже. Только для старших моделей.

Советник (/advisor) — вторая, более сильная модель, с которой основная сверяется в ключевые моменты задачи. Экспериментальная возможность.

Запасная модель — если основная перегружена, сессия продолжит на запасной. Задаётся флагом --fallback-model.

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

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

Где запускается Claude Code

Харнес — это один и тот же движок, у которого несколько лицевых сторон.

ГдеЧто этоОсобенности
Терминалпрограмма claudeполный набор возможностей, отсюда всё началось
VS Codeрасширениеправки показываются в окне редактора, агент видит выделенный код
JetBrainsплагинпросмотр правок в IDE, общий с терминалом сеанс
Приложение Desktopпрограмма для macOS и Windowsнесколько сессий рядом, просмотр диффов, встроенный браузер, подключение по SSH
Вебclaude.ai/codeоблачные сессии, работают без вашего компьютера
Телефонприложение Claudeоблачные сессии и управление сессиями на компьютере
Slack@Claude в каналезадача из переписки уходит в облачную сессию
CIGitHub Actions, GitLab CI/CDзапуск по событию, без человека

Локальные поверхности делят между собой всё: настройки, инструкции проекта, MCP-серверы, историю сессий. Разговор, начатый в терминале, можно открыть в приложении командой /desktop. Облачные сессии живут отдельно: у них своё окружение, и до файлов на вашем диске они не дотягиваются.

Установка. Основной способ — собственный установщик: одна команда для macOS и Linux, одна для PowerShell. Есть пакеты для Homebrew, WinGet и npm. Поддерживаются macOS 13 и новее, Windows 10 и новее, распространённые дистрибутивы Linux; нужно от 4 ГБ памяти. Установленная так программа обновляется сама, в фоне. Канал обновлений выбирается: самый свежий или стабильный, с задержкой около недели.

На Windows два варианта. Запуск напрямую: всё работает, кроме песочницы; желательно поставить Git for Windows, чтобы у агента был Bash. Запуск в WSL2: это полноценный Linux со всеми возможностями, включая песочницу, но без интеграции с браузером Chrome.

Браузер: какие есть варианты

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

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

Как агент видит страницу. Тут три способа, и от них зависят точность и расход токенов:

  • Снимок экрана. Картинка, как её видит человек. Универсально, но дорого по токенам, и попадать по кнопке приходится по координатам.
  • Дерево доступности. Это структурное описание страницы, которым пользуются программы чтения с экрана: «кнопка „Войти“, поле „Почта“, ссылка „Забыли пароль“». Агент получает его текстом, где у каждого элемента есть короткий номер, и нажимает по номеру, а не по координатам. Дешевле и точнее картинки.
  • Внутренности браузера. Консоль, сетевые запросы, стили, замеры скорости — то, что вы видите в инструментах разработчика.

Нужно ли окно. На ноутбуке окно есть. В контейнере, на сервере и в CI его нет, и браузер должен работать в режиме без интерфейса (headless).

Сводка всех вариантов:

ВариантЧей браузерКак видит страницуБез окнаКто делает
WebFetch, WebSearchникакойтекст в пересказедавстроено
Claude in Chromeваш, с входамистраница, снимки, консоль, сетьнетAnthropic
Встроенный браузер Desktopчистый, в приложениистраница и снимкинетAnthropic
Playwright MCPсвой профиль или ваш браузердерево доступности, по желанию снимкидаMicrosoft
Playwright CLIчистый по умолчаниюдерево доступности, по запросуда, по умолчаниюMicrosoft
Chrome DevTools MCPсвой или уже запущенный Chromeдерево, снимки, консоль, сеть, замеры скоростидакоманда Chrome DevTools
Firefox DevTools MCPотдельный профиль Firefoxдерево и снимкидаMozilla
Свой скрипт на Playwright или Puppeteerлюбойчто напишете в скриптедавы и агент
Облачный браузерна серверах сервисазависит от сервисадасторонние платные сервисы
Управление компьютеромлюбой, как окно на экранеснимок экрананетAnthropic

Теперь по порядку.

Встроенные инструменты

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

Claude in Chrome: ваш настоящий браузер

Это расширение для Chrome и Edge плюс мост к Claude Code. Включается флагом claude --chrome или командой /chrome. Агент работает в настоящем окне вашего браузера, в новой вкладке, и видит сайты так, как их видите вы: с вашими входами в почту, панели управления, трекеры.

Что он умеет: переходить по страницам, нажимать и заполнять формы, читать текст страницы, консоль и сетевые запросы, делать снимки экрана, записывать GIF с ходом действий.

Это и сила, и риск. Сила в том, что агент может сделать что-то в сервисе, где у вас уже открыт сеанс, не получая паролей. Риск в том же самом. Поэтому доступ выдаётся в расширении по каждому сайту отдельно, а на входе в аккаунт и на капче агент останавливается и ждёт вас.

Как устроена связь. Расширение не может само общаться с программой на компьютере, поэтому Claude Code при первом включении регистрирует в системе небольшой посредник (native messaging host). Через него расширение и терминальная сессия обмениваются командами. У меня он лежит в %APPDATA%\Claude Code\ChromeNativeHost.

Ограничения: нужна подписка и вход через аккаунт, с ключом API не работает; в WSL не работает; режима без окна нет; открытое на странице системное окно с вопросом блокирует управление.

Встроенный браузер приложения Desktop

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

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

Playwright MCP

Playwright — это библиотека Microsoft для автоматизации браузеров; на ней пишут сквозные тесты. У неё есть MCP-сервер, который даёт агенту инструменты управления браузером: открыть адрес, нажать, ввести текст, сделать снимок.

Подключается одной командой:

Shell
claude mcp add playwright npx @playwright/mcp@latest

Или плагином из официального маркетплейса, который делает то же самое:

Shell
claude plugin install playwright@claude-plugins-official

Главная особенность — по умолчанию агент работает с деревом доступности, а не с картинкой. Он запрашивает снимок страницы и получает текст примерно такого вида:

YAML
- heading "Вход" [level=1]
- textbox "Почта" [ref=e12]
- textbox "Пароль" [ref=e13]
- button "Войти" [ref=e15]
- link "Забыли пароль?" [ref=e16]

Дальше он говорит «нажми e15», и сервер нажимает именно эту кнопку. Модели не нужно угадывать координаты, и токенов уходит заметно меньше, чем на картинку. Режим с координатами тоже есть: он включается флагом --caps=vision и нужен там, где дерево не помогает, например на холсте с графикой.

Что настраивается флагами:

ФлагЧто делает
--browserкакой браузер: Chrome, Edge, Firefox или WebKit
--headlessработать без окна; по умолчанию окно показывается
--isolatedпрофиль только в памяти, после закрытия ничего не остаётся
--user-data-dirсвой путь к профилю
--storage-stateзагрузить сохранённые куки в изолированную сессию
--extensionподключиться к вашему уже открытому Chrome или Edge через расширение Playwright
--cdp-endpointподключиться к браузеру, запущенному с отладочным портом

Про профиль стоит понимать одно. По умолчанию он постоянный: сервер заводит собственную папку профиля и хранит в ней входы между запусками. Это не ваш личный профиль, но если вы один раз вошли в сервис в этом окне, вход сохранится. Для тестов, где нужна чистота, ставят --isolated.

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

Playwright CLI

У того же Playwright есть второй способ, сделанный специально для агентов в терминале: обычная программа командной строки вместо MCP-сервера.

Shell
npm install -g @playwright/cli@latest
playwright-cli install --skills

Вторая команда ставит скилы для Claude Code: из них агент узнаёт, какие команды есть и как ими пользоваться. Дальше он просто вызывает программу через Bash:

Shell
playwright-cli open https://example.com
playwright-cli snapshot --depth=3
playwright-cli click e15

В чём разница с MCP-сервером. MCP-сервер возвращает дерево страницы после каждого действия, и оно оседает в контексте. Программа командной строки печатает только то, что запросили: снимок нужной глубины, результат поиска элемента. Авторы Playwright сами пишут, что для агентов-программистов такой путь экономнее, а MCP-сервер лучше там, где нужно долго исследовать страницу с сохранением состояния.

По умолчанию браузер здесь запускается без окна и с чистым профилем в памяти; окно включается флагом --headed, сохранение профиля — флагом --persistent.

Chrome DevTools MCP

Этот сервер делает команда инструментов разработчика Chrome. Нажимать и вводить текст он тоже умеет, но его смысл в другом: он открывает агенту то, что вы видите в панели разработчика.

  • Скорость. Записать трассировку загрузки страницы и разобрать, что её тормозит.
  • Сеть. Список запросов, заголовки и тела ответов.
  • Консоль. Сообщения и ошибки со стеком, приведённым к исходникам.
  • Стили. Какие правила CSS реально применились к элементу.
  • Аудит. Проверка Lighthouse.
  • Память. Снимки кучи для поиска утечек.

Ставится плагином:

Shell
claude plugin marketplace add ChromeDevTools/chrome-devtools-mcp
claude plugin install chrome-devtools-mcp@chrome-devtools-plugins

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

Shell
chrome --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-debug
npx -y chrome-devtools-mcp@latest --browser-url http://127.0.0.1:9222

Выбор между ним и Playwright простой. «Пройди по форме и проверь, что заказ создаётся» — это Playwright. «Страница грузится четыре секунды, выясни почему» — это Chrome DevTools. Работает он только с Chrome. И по умолчанию отправляет Google статистику использования; она отключается флагом --no-usage-statistics.

Firefox DevTools MCP

У Mozilla есть свой официальный сервер, пока в ранней версии:

Shell
claude mcp add firefox-devtools npx @mozilla/firefox-devtools-mcp@latest

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

Для Safari отдельного сервера я не нашёл. Движок WebKit, на котором он построен, доступен через Playwright: флаг --browser webkit.

Свой скрипт

Самый простой способ часто забывают: никаких серверов, агент пишет обычный скрипт на Playwright или Puppeteer и запускает его через Bash.

JavaScript · check-login.mjs
import { chromium } from 'playwright';
const browser = await chromium.launch();
const page = await browser.newPage();
await page.goto('http://localhost:3000/login');
await page.getByLabel('Почта').fill('[email protected]');
await page.getByRole('button', { name: 'Войти' }).click();
console.log(await page.getByRole('alert').textContent());
await page.screenshot({ path: 'login.png' });
await browser.close();

Агент запускает скрипт, читает напечатанный текст, а снимок открывает инструментом Read и смотрит на него как на картинку.

У этого способа три достоинства. В контекст попадает только то, что скрипт напечатал. Скрипт остаётся в репозитории и превращается в тест. И он одинаково работает на ноутбуке, в контейнере и в CI. Недостаток один: это не диалог со страницей. Каждое «а что там теперь» — новый запуск.

Если в проекте уже есть сквозные тесты, это и есть лучший способ проверки: агент дописывает тест и запускает его. На этом же построены встроенные скилы /run и /verify: они сами определяют тип проекта, запускают приложение и смотрят на результат, а /run-skill-generator записывает найденный рецепт запуска в скил проекта.

Облачные браузеры и сервисы сбора данных

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

СервисДля чего
Browserbaseбраузеры в облаке; управление описанием действия словами
browser-useуправляет вашим локальным Chrome или облачным браузером сервиса
Firecrawlне управление, а сбор: страница или целый сайт превращаются в Markdown
Bright Dataсбор данных и браузер с обходом защиты от роботов

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

Как выбрать

  • Проверить свой сайт на локальном сервере — встроенный браузер Desktop или Playwright; в проекте с тестами — свой скрипт.
  • Сделать что-то в сервисе, где вы уже вошли — Claude in Chrome. Или Playwright с флагом --extension.
  • Найти, почему страница медленная или что падает в консоли — Chrome DevTools MCP.
  • Работа на сервере, в контейнере, в CI — Playwright CLI, Playwright MCP с --headless или свой скрипт. Расширение для Chrome там не работает.
  • Ошибка только в одном браузере — Playwright с нужным --browser или сервер Mozilla.
  • Массовый сбор данных — облачные сервисы.

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

Настольные и мобильные приложения

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

Сам Claude Code перебирает варианты в таком порядке: готовый коннектор или MCP-сервер программы → команда в терминале → браузер → панель симулятора → управление экраном. Разберём их в этом же порядке.

Не трогать окно: файлы и командная строка

Самый надёжный способ работать с программой — не открывать её вовсе.

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

Командная строка. У многих настольных программ есть режим без окна. Blender рендерит сцену из командной строки, Android Studio собирает проект через Gradle, Xcode — через xcodebuild, Docker Desktop управляется командой docker. Агенту достаточно инструмента Bash.

Скриптовые интерфейсы операционной системы

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

СистемаИнтерфейсЧто умеет
WindowsPowerShell и COMуправлять приложениями Office как объектами: открыть книгу, заполнить ячейки, сохранить
WindowsUI Automationчитать дерево элементов любого окна и нажимать их; это интерфейс для программ чтения с экрана
macOSAppleScript, JXAпосылать команды приложениям, которые поддерживают сценарии: Finder, Почта, Safari, Заметки
Linuxxdotool, ydotoolимитировать клавиатуру и мышь, двигать окна

Пример для Windows. Так агент записывает значение в открытую таблицу Excel, не видя её окна:

PowerShell
$excel = New-Object -ComObject Excel.Application
$excel.Visible = $true
$book = $excel.Workbooks.Open("C:\reports\sales.xlsx")
$book.Sheets.Item(1).Range("B2").Value2 = 1250
$book.Save()
$excel.Quit()

А так на macOS он просит Finder показать папку:

Shell
osascript -e 'tell application "Finder" to open folder "Documents" of home'

Отличие от управления мышью принципиальное. Команда «запиши 1250 в ячейку B2» либо выполнилась, либо вернула ошибку. Ей не мешает ни разрешение экрана, ни всплывшее поверх окно, ни сменившаяся тема оформления.

На macOS такие сценарии требуют разрешений в системных настройках: «Автоматизация» для команд приложениям и «Универсальный доступ» для управления интерфейсом. На Linux xdotool работает только под X11, для Wayland нужен ydotool.

MCP-серверы программ

Многие программы теперь сами дают агентам официальный вход — MCP-сервер. Это самый удобный путь: программа объявляет понятные инструменты, а не заставляет угадывать, куда нажать.

ПрограммаСерверЧто даёт
Figmaофициальный, от Figmaконтекст макета, переменные, снимки, запись на холст
IDE от JetBrainsвстроен в IDE с версии 2025.2сборка, ошибки в файле, запуск конфигураций, поиск и рефакторинг
Xcodeофициальный плагин от Appleсборка и тесты, предпросмотр SwiftUI, симуляторы, логи сборки
Unityофициальный плагин и серверы сообществасцены, объекты, скрипты, тесты
Blenderот сообществавыполнение Python внутри Blender, рендер сцены
Симулятор iOS, Androidот сообществадерево элементов экрана, нажатия, снимки

Подключается такой сервер как любой другой. Например, Figma:

Shell
claude mcp add --transport http figma https://mcp.figma.com/mcp

С IDE отдельная история: помимо MCP-сервера у JetBrains и VS Code есть собственная интеграция с Claude Code. Через неё агент видит открытый файл, выделенный фрагмент и ошибки, которые показывает редактор, а правки появляются в окне сравнения.

Есть и серверы общего назначения, которые открывают агенту весь рабочий стол: для Windows — сервер от сообщества, который читает дерево элементов окон через UI Automation, нажимает, печатает и запускает PowerShell; для macOS — сервер, который выполняет сценарии AppleScript. Это мощно и поэтому опасно: по сути, полный доступ к системе. Сами авторы об этом предупреждают. К серверам от сообщества стоит относиться как к любой чужой программе с такими правами: посмотреть код, посмотреть, что он отправляет наружу.

Приложения на Electron

Многие настольные программы — Slack, VS Code, Discord, Notion — написаны на Electron. Внутри это браузер Chromium, и к нему применимо всё из раздела про браузеры.

Если это ваше собственное приложение, у Playwright есть поддержка Electron, пока экспериментальная: скрипт запускает приложение, получает его окна и работает с ними как со страницами.

JavaScript · check-app.mjs
import { _electron as electron } from 'playwright';
const app = await electron.launch({ args: ['main.js'] });
const window = await app.firstWindow();
await window.getByRole('button', { name: 'Новый документ' }).click();
await window.screenshot({ path: 'app.png' });
await app.close();

Второй путь — запустить приложение с отладочным портом, флагом --remote-debugging-port, и подключить к этому порту Chrome DevTools MCP так же, как к обычному Chrome.

Мобильные приложения

iOS. В приложении Desktop на macOS есть панель симулятора iOS. Агент собирает приложение, ставит его в симулятор, нажимает, вводит текст и делает снимки. Управление экраном для этого не используется: панель работает через штатные средства Apple, поэтому системные разрешения на запись экрана не нужны. Работает только с симулятором, не с настоящим телефоном.

Из терминала то же делается командой xcrun simctl и MCP-серверами для симулятора.

Android. Здесь всё держится на adb, штатной утилите Android. Через неё агент ставит сборку на эмулятор или подключённый телефон, запускает экран, читает логи, делает снимок, нажимает по координатам:

Shell
adb install -r app/build/outputs/apk/debug/app-debug.apk
adb shell am start -n com.example.app/.MainActivity
adb logcat -d -t 200
adb exec-out screencap -p > screen.png

Есть и MCP-серверы для мобильных устройств, которые вместо координат дают дерево элементов экрана — так же, как Playwright для страниц.

Управление компьютером: когда остальное не подошло

Управление компьютером (computer use) — это когда агент работает с машиной как человек: смотрит на снимок экрана, двигает мышь, нажимает клавиши. Так можно дотянуться до того, у чего нет ни командной строки, ни программного интерфейса: старая корпоративная программа, панель управления оборудованием, проприетарный инструмент.

Где это доступно. В приложении Desktop — на macOS и на Windows. В терминале — только на macOS, включается через /mcp. Возможность помечена как предварительная и требует личной подписки.

Как это устроено с точки зрения безопасности:

  • Доступ выдаётся по приложениям. Агент просит разрешение на конкретную программу, и вы его даёте на сессию.
  • У приложений разные уровни. Браузеры — только смотреть. Терминалы и редакторы кода — смотреть и кликать, но не печатать: иначе это был бы полный доступ к оболочке в обход всех правил. Остальное — полное управление.
  • Работать может только одна сессия одновременно. Остальные программы на время хода скрываются, а терминал с самим Claude Code в снимки не попадает.
  • Esc прерывает работу из любого места.

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

Рядом стоит Dispatch — возможность дать задачу с телефона приложению Desktop на вашем компьютере. Оно само запускает сессию, а вам приходит уведомление, когда работа закончена или нужно подтверждение.

Как выбрать

Что нужноЧем делать
Создать или изменить документ, таблицу, презентациюработа с файлом, без запуска программы
Собрать, запустить, отрендеритькомандная строка программы
Управлять приложением Office на WindowsPowerShell и COM
Команды приложениям на macOSAppleScript
Макеты, IDE, игровой движок, 3D-редакторMCP-сервер этой программы
Своё приложение на ElectronPlaywright
Приложение для iOSпанель симулятора в Desktop или xcrun simctl
Приложение для Androidadb
Программа без какого-либо программного входауправление компьютером

Работа без человека

Всё, что описано выше, — про интерактивный режим, где вы сидите рядом. Но тот же движок запускается и без интерфейса.

Shell
claude -p "Найди в логах причину падения и опиши её одним абзацем" --output-format json

Флаг -p означает: выполнить задачу, напечатать результат и выйти. Вывод бывает трёх видов: обычный текст, один JSON с результатом, стоимостью и идентификатором сессии, или поток JSON-событий по мере работы. Можно задать схему, и тогда ответ придёт в строго заданной структуре.

Что важно в этом режиме:

  • Спрашивать некого. Всё, что потребовало бы подтверждения, отклоняется. Нужные действия разрешают заранее: флагом --allowedTools или режимом разрешений.
  • Окно доверия папке не показывается. Поэтому запускать так стоит только в папках, которым вы доверяете.
  • Есть ограничитель бюджета: --max-budget-usd остановит работу, когда потрачена заданная сумма.
  • Есть «голый» режим --bare: без хуков, плагинов, памяти и автоматического чтения инструкций. Он даёт предсказуемый результат в скриптах, где окружение машины не должно влиять на ответ.

На этом режиме построены готовые интеграции: действие для GitHub Actions и шаблон для GitLab CI, которые запускают агента на событие в репозитории — новый запрос на слияние, упавшая сборка, упоминание в комментарии.

А если нужно встроить агента в свою программу, есть Agent SDK для Python и TypeScript. Это тот же цикл, те же инструменты и та же работа с контекстом, только в виде библиотеки: вы вызываете функцию и получаете поток событий.

Фоновые сессии

Интерактивная сессия занимает терминал. Если задача на час, а смотреть на неё незачем, сессию можно увести в фон.

Shell
claude --bg "Обнови зависимости и почини то, что сломается"
claude agents

Первая команда запускает сессию в фоне и сразу возвращает управление. Вторая открывает экран со списком всех фоновых сессий, разложенных по состоянию: ждёт вашего ответа, работает, закончила. Из списка в любую можно войти, посмотреть и выйти обратно, не останавливая её. Уже идущую сессию отправляет в фон команда /background.

Как это работает внутри. За фоновыми сессиями следит служебный процесс-супервизор. Он стартует сам, держит список сессий, перезапускает упавшие и останавливает те, что час простаивают без присмотра. Его состояние лежит в папках daemon и jobs домашней директории. Сон компьютера сессии переживают, перезагрузку — нет: после неё они помечаются остановленными и продолжаются, когда вы в них войдёте.

Чтобы фоновые сессии не мешали вам и друг другу, каждая перед первой правкой переезжает в собственную рабочую копию репозитория. В основную ветку они не пушат и ничего не сливают сами.

Как сессии и агенты взаимодействуют

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

СубагентыСценарии (workflows)Команды агентовСообщения между сессиями
Кто управляетглавный агентскриптагент-лидервы или сами агенты
Общаются между собойнет, только отчёт главномунет, результаты собирает скриптда, напрямуюда
Контексту каждого свой, чистыйу каждого свойу каждого свойу каждой сессии свой
Числоединицыдо сотеннесколькосколько сессий открыто
Когда братьразведка, независимый кусок работыбольшая однотипная работазадача, где участникам нужно спорить и договариватьсяуже идущие сессии должны обменяться сведениями

Субагенты описаны выше: главный агент раздаёт задачи и получает отчёты. Между собой они не общаются.

Сценарии (dynamic workflows). Когда субагентов нужно много, управлять ими из разговора становится неудобно: каждый отчёт попадает в контекст главного агента. Сценарий решает это иначе. Агент пишет небольшой скрипт на JavaScript, а харнес его выполняет: запускает агентов параллельно или цепочкой, передаёт результаты из шага в шаг. Промежуточные результаты остаются в переменных скрипта и контекст не занимают. Типичный пример — проверить двадцать файлов по пяти критериям и каждую находку перепроверить отдельным агентом. Запускается словом ultracode в сообщении или просьбой «используй workflow». Перед запуском харнес спрашивает подтверждение, потому что десятки агентов — это десятки сессий по расходу.

Команды агентов (agent teams) — экспериментальная возможность, выключена по умолчанию. Здесь участники равноправнее: есть лидер и несколько напарников, общий список задач и почтовые ящики. Напарники пишут друг другу напрямую, берут задачи из общего списка и отмечают сделанное. Это подходит там, где работа требует обсуждения: один исследует гипотезу, другой её опровергает.

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

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

Расписание

Запускать агента по времени можно на трёх уровнях.

Внутри сессии. Команда /loop 5m проверь, закончилась ли сборка повторяет задачу, пока сессия открыта. Без интервала агент сам выбирает паузу между проверками. Работает это только пока сессия жива и простаивает.

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

В облаке. Команда /schedule создаёт задачу, которая выполняется на серверах Anthropic. Ваш компьютер может быть выключен. Запускается она по расписанию (не чаще раза в час), запросом к API или по событию в GitHub, например при открытии запроса на слияние.

Удалённая работа

Последняя большая тема: как работать с агентом, который находится не там, где вы. Вариантов четыре, и они отличаются тем, где исполняется код.

Удалённое управление

Агент работает на вашем компьютере, а управляете вы им с телефона или из браузера на другой машине.

Shell
claude remote-control

После этой команды сессия появляется на claude.ai/code и в приложении на телефоне. Оттуда можно писать сообщения, смотреть, что делает агент, подтверждать разрешения.

Как устроено соединение. Ваш компьютер сам подключается к серверам Anthropic исходящим HTTPS-запросом и ждёт сообщений. Входящих портов он не открывает, пробрасывать ничего не надо. Код, файлы, инструменты и MCP-серверы остаются на вашей машине; через серверы проходит только переписка: сообщения, ответы и сведения о вызовах инструментов.

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

Облачные сессии

Здесь агент работает на виртуальной машине Anthropic. Ваш компьютер не нужен вообще.

Shell
claude --cloud "Добавь проверку формата телефона в форму регистрации"

То же делается с сайта claude.ai/code и с телефона. Машина получает ваш репозиторий с GitHub, агент работает в отдельной ветке и по окончании предлагает запрос на слияние.

Что стоит знать об этой среде:

  • Окружение настраивается. Можно задать скрипт подготовки, который поставит нужные пакеты, переменные окружения и уровень доступа в сеть: никакого, ограниченный (реестры пакетов и GitHub) или полный.
  • Ключи GitHub в машину не попадают. Они остаются на серверах Anthropic, а запросы к GitHub идут через прокси, который подставляет их сам.
  • Машина засыпает. После нескольких минут простоя она ставится на паузу; фоновые процессы при этом не сохраняются.
  • Сессию можно забрать к себе. Команда /teleport переносит облачный разговор и ветку в ваш терминал. В обратную сторону, из терминала в облако, готовую сессию перенести нельзя.

Подключение по SSH из приложения

В приложении Desktop в списке окружений есть пункт SSH. Вы указываете адрес машины, приложение само ставит на неё Claude Code и запускает там сессию. Интерфейс остаётся у вас, а код исполняется на удалённой машине. Постоянные подключения описываются в настройках:

JSON · ~/.claude/settings.json
{
"sshConfigs": [
{
"id": "dev-vm",
"name": "Dev VM",
"sshHost": "[email protected]",
"sshPort": 22
}
]
}

Виртуальная машина в сети: как собрать самому

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

Claude Code — обычная программа для Linux, поэтому способов несколько.

Способ первый: SSH и tmux. Заходите на машину по SSH, запускаете tmux, в нём — claude. tmux нужен, чтобы сессия пережила обрыв связи: отключились, подключились снова, вернулись в тот же терминал. Это самый простой вариант, и работает он везде.

Способ второй: удалённое управление с машины. На машине в tmux запускаете claude remote-control и дальше работаете с ней с телефона или из браузера. SSH нужен только для первого запуска. Входящие порты открывать не надо, потому что машина подключается наружу сама. Для команды claude remote-control есть серверный режим: одна такая команда принимает несколько сессий, каждую можно запускать в своей рабочей копии репозитория.

Способ третий: фоновые сессии. На машине запускаете задачи через claude --bg и смотрите на них через claude agents. Супервизор держит их без открытого терминала.

Способ четвёртый: приложение Desktop по SSH, описанный выше. Удобен, если хочется графический интерфейс и диффы, а не терминал.

Способ пятый: без интерфейса. Скрипт или планировщик на машине вызывает claude -p с задачей. Подходит для ночных прогонов и обработки очереди.

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

Способ входаЧто даётЧего не даёт
Обычный вход (/login)всё, что есть в подпискетребует один раз открыть ссылку в браузере на другом устройстве
Долгоживущий токен (claude setup-token)запросы к модели по подписке, удобно для скриптовудалённое управление и браузер
Ключ APIзапросы к модели с оплатой по токенамвсё, что привязано к подписке: удалённое управление, облачные сессии

И пара советов из практики. Если машина выделена под агента, включите на ней песочницу: это Linux, там она работает полностью. Давайте машине отдельный ключ доступа к репозиторию с минимальными правами, а не свой личный. И помните, что изоляция машины защищает вашу систему, но не то, до чего сама машина может дотянуться по сети.

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

Провайдеры и локальные модели

Откуда берётся модель. Основных пути два: подписка Claude или ключ API с оплатой по токенам. Для компаний есть третий: модели Claude через облако — Amazon Bedrock, Google Cloud или Microsoft Foundry. Выбирается переменной окружения.

Важно понимать, что часть возможностей привязана именно к подписке и серверам Anthropic. Через облачного провайдера или по ключу API не работают удалённое управление, облачные сессии, расширение для браузера, управление компьютером, приложение Desktop. Сам цикл агента, инструменты, память, скилы, хуки и MCP работают везде одинаково.

Можно ли запустить Claude Code на чужой или локальной модели? Официально — нет: Anthropic такой режим не поддерживает. Технически адрес API подменяется переменной ANTHROPIC_BASE_URL, и некоторые вендоры документируют подключение своих моделей таким способом. Но системный промпт и инструменты Claude Code рассчитаны на модели Claude, и качество с другими заметно ниже. Если нужна работа на своих моделях, лучше взять харнес, который для этого сделан.

Лимиты и стоимость

На подписке расход ограничен окнами: пятичасовым и недельным, плюс отдельные недельные лимиты на старшие модели. Они общие для всего аккаунта: терминал, приложение, облачные сессии и обычный чат тратят одну квоту. Сколько осталось, показывает /usage; там же видно, что именно расходует лимит — какие скилы, субагенты и MCP-серверы.

По ключу API лимитов по окнам нет, оплата идёт за токены. Для ориентира: документация называет среднюю цифру около 13 долларов на разработчика за активный день.

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

  • Длинная сессия после паузы. Кэш остыл, и весь разговор оплачивается заново.
  • Параллельные агенты. Каждый субагент, напарник или фоновая сессия — отдельный разговор со своим контекстом.
  • Высокое усилие и старшая модель там, где задача этого не требует.
  • Задачи по расписанию. Каждое срабатывание отправляет полный контекст.
  • Раздутые инструкции. Они оплачиваются в каждом запросе каждой сессии.

Что уходит с вашей машины

Короткая, но важная часть.

Что отправляется. На серверы Anthropic уходит то, что попало в запрос: ваши сообщения, содержимое прочитанных файлов, вывод команд, ответы модели. Файлы, которые агент не читал, никуда не отправляются.

Обучение. На личных тарифах использование ваших данных для обучения моделей — это переключатель в настройках приватности. На корпоративных тарифах и по API данные для обучения по умолчанию не используются.

Хранение на серверах. По умолчанию 30 дней; если на личном тарифе разрешено обучение — до пяти лет.

Хранение у вас. Разговоры лежат в домашней папке открытым текстом 30 дней. Об этом стоит помнить, когда агент читает файлы с секретами.

Телеметрия. Метрики использования и отчёты об ошибках отключаются переменными окружения; одна переменная выключает весь необязательный трафик сразу.

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

Чем Claude Code отличается от похожих инструментов

Все современные харнесы для программирования устроены по одной схеме: цикл, инструменты, инструкции проекта, разрешения. Отличаются они решениями в деталях. Коротко о главных; подробное сравнение сорока с лишним инструментов — в отдельной статье.

Claude CodeCodexCursorGitHub CopilotOpenCode
Кто делаетAnthropicOpenAIAnysphereGitHubсообщество, команда SST
Исходный кодзакрытCLI открытзакрытCLI закрыт, расширение открытооткрыт
Главная форматерминалтерминал и облакосвой редакторредактор и GitHubтерминал
Моделитолько Claudeмодели OpenAIмногих вендоровмногих вендоровлюбые, включая локальные
ИнструкцииCLAUDE.md, правила по путямAGENTS.md.cursor/rulescopilot-instructions.mdAGENTS.md
Поиск по кодуагентный, без индексаагентныйиндекс с эмбеддингами плюс агентныйиндекс плюс агентныйагентный
Песочницапо желанию; нет на Windows без WSLвключена по умолчанию на трёх ОСвключена на macOS и Linuxпо желаниюнет
Облачный режиместьестьестьестьнет

Что из этого следует на практике.

Сильные стороны Claude Code — глубина настройки и работа без присмотра. Четыре уровня инструкций, правила с привязкой к путям, скилы, субагенты со своей моделью, три десятка событий для хуков, моды, сценарии с десятками агентов, фоновые и облачные сессии. Ни у кого больше нет такого набора целиком.

Слабые стороны — закрытый код и привязка к одному вендору. Работать можно только с моделями Claude, а подписка действует только в продуктах Anthropic. Песочница не включена по умолчанию и не работает на Windows без WSL — у Codex она включена сразу и на всех трёх системах.

Что переносится. Файлы из папки .claude стали чем-то вроде общего формата: скилы, правила и хуки частично читают Cursor, Copilot, OpenCode и другие. А AGENTS.md, который понимают почти все, Claude Code читает, если нет своего файла инструкций. Команда /import переносит настройки в обратную сторону — из Codex, Gemini CLI и Cursor.

Коротко

  • Claude Code — это харнес: программа на вашем компьютере, которая даёт модели инструменты и управляет тем, что модель видит. Модель думает, харнес делает.
  • Работа идёт циклом: модель просит вызвать инструмент, харнес выполняет и возвращает результат, и так до ответа без вызовов. Каждый запрос несёт весь разговор.
  • Правка файла — это точная замена уникального фрагмента. Поиск — обычный поиск по файлам, без индекса.
  • Контекст сжимается сам. Переживает сжатие то, что записано в файлы: инструкции, правила, память. Сказанное только в чате может потеряться.
  • Знание передаётся тремя способами: инструкции и правила (всегда в контексте), скилы (по требованию), авто-память (пишет сам агент, лежит в домашней папке).
  • Субагент — отдельный контекст для отдельной задачи. Экономит главный контекст, но теряет детали на передаче и стоит как ещё одна сессия.
  • Хук — код, который харнес выполняет сам. Всё, что должно происходить всегда, делается хуком, а не строчкой в инструкциях.
  • Разговоры, память и копии файлов лежат в ~/.claude открытым текстом. Настройки проекта — в .claude в репозитории.
  • Разрешения и авто-режим защищают от случайностей. Настоящую границу дают песочница, контейнер и виртуальная машина.
  • Один движок работает в терминале, редакторе, приложении, облаке и без интерфейса. На своей виртуальной машине он запускается как обычная программа для Linux, а управлять им можно с телефона, не открывая портов.

Источники