Анализ исходного кода Claude Code: почему он лучше других инструментов программирования на ИИ?

Оригинальное название: «Разбор исходного кода Claude Code от Anthropic в одной статье: почему он просто лучше других?»

Оригинальный автор: Yuker, AI-исследователь

31 марта 2026 года исследователь безопасности Chaofan Shou обнаружил, что в npm-релизе пакета Claude Code от Anthropic не был удален файл source map.

Это означает, что полный исходный код Claude Code на TypeScript, состоящий из 512 000 строк и 1903 файлов, был раскрыт в публичном доступе.

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

1. В чем фундаментальная разница между Claude Code и другими инструментами программирования на ИИ?

2. Почему процесс написания кода с ним «ощущается» лучше, чем с другими?

3. Что именно скрыто в 510 000 строк кода?

После прочтения моя первая реакция была: это не просто ИИ-ассистент для программирования; это операционная система.

I. Начнем с истории: если бы вы нанимали удаленного программиста

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

Как бы вы с этим справились?

Если бы вы были Cursor: вы бы посадили его рядом с собой, и каждый раз, когда ему нужно ввести команду, вы бы поглядывали и нажимали «разрешить». Это просто, но вам нужно следить за ним постоянно.

Если бы вы были GitHub Copilot Agent: вы бы дали ему совершенно новую виртуальную машину. После завершения он отправляет код, вы проверяете его и затем объединяете. Это безопасно, но он не видит ваше локальное окружение.

Если бы вы были Claude Code:

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

Вот три совершенно разные философии безопасности:

Почему Anthropic выбрала самый сложный путь?

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

Но какова цена? Они написали для этого 510 000 строк кода.

II. Ваше восприятие Claude Code против реального Claude Code

Большинство людей думают, что ИИ-инструменты для программирования работают так:

Ввод пользователя → Вызов API LLM → Получение результата → Показ пользователю

Реальный Claude Code работает так:

Ввод пользователя
→ Динамическая сборка 7 слоев системных промптов
→ Внедрение состояния Git, соглашений проекта, исторической памяти
→ 42 инструмента, каждый со своей инструкцией
→ LLM решает, какой инструмент использовать
→ 9 уровней проверки безопасности (парсинг AST, ML-классификаторы, проверки песочницы...)
→ Разрешение конфликтов прав доступа (локальная клавиатура/IDE/хук/ИИ-классификатор соревнуются одновременно)
→ Анти-усталостная задержка 200 мс
→ Выполнение инструмента
→ Возврат результатов в потоковом режиме
→ Контекст приближается к лимиту? → Трехступенчатое сжатие (микросжатие → автосжатие → полное сжатие)
→ Нужен параллелизм? → Генерация роя субагентов
→ Цикл до завершения задачи

Я верю, что всем очень любопытно узнать об этом, но не волнуйтесь, давайте разберем все по порядку.

III. Первый секрет: промпты не пишутся, они «собираются»

Откройте src/constants/prompts.ts, и вы увидите эту функцию:

Заметили SYSTEM_PROMPT_DYNAMIC_BOUNDARY?

Это разделитель кэша. Содержимое выше разделителя статично и может быть кэшировано API Claude для экономии затрат на токены. Содержимое ниже разделителя динамично — ваша текущая ветка Git, конфигурация проекта CLAUDE.md, ранее предоставленные воспоминания о предпочтениях... каждое взаимодействие уникально.

Что это значит?

Anthropic рассматривает подсказки как выходные данные компилятора для оптимизации. Статическая часть — это «скомпилированный бинарный файл», а динамическая часть — «параметры времени выполнения». Преимущества этого подхода:

1. Экономия затрат: статическая часть кэшируется, избегая избыточных списаний

2. Скорость: попадания в кэш напрямую пропускают обработку этих токенов

3. Гибкость: динамическая часть позволяет каждому взаимодействию знать текущее окружение

У каждого инструмента есть свое «Руководство пользователя»

Еще более поразительно то, что каждая директория инструмента содержит файл prompt.ts — это руководство пользователя, специально адаптированное для LLM.

Посмотрите на BashTool (src/tools/BashTool/prompt.ts, около 370 строк):

Это не документ для людей, это кодекс поведения для ИИ. Каждый раз, когда запускается Claude Code, эти правила внедряются в системные промпты.

Вот почему Claude Code никогда не делает принудительный git push --force самостоятельно, в то время как некоторые инструменты могут — дело не в том, что модель умнее, а в том, что в подсказках уже прописаны правила.

Плюс, внутренняя версия Anthropic отличается от той, что используете вы

В коде есть множество веток, таких как эта:

ant относится к внутренним сотрудникам Anthropic. Их версия имеет более подробные рекомендации по стилю кода («Не пишите комментарии, если причина не очевидна»), более агрессивную стратегию вывода («Пирамидальная структура текста») и некоторые экспериментальные функции, все еще находящиеся в A/B тестировании (агент верификации, агент исследования и планирования).

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

IV. Второй секрет: 42 инструмента, но вы видели лишь верхушку айсберга

Откройте src/tools.ts, и вы увидите реестр инструментов:

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

Почему это сделано?

Потому что для каждого дополнительного инструмента системный промпт требует дополнительного описания, а токен требует больше денег. Если вы просто хотите, чтобы Claude Code помог вам изменить одну строку кода, ему не нужно загружать 'Cron Task Scheduler' и 'Team Collaboration Manager'.

Есть еще более умный дизайн:

Установите CLAUDE_CODE_SIMPLE=true, и у Claude Code останется только три инструмента: Bash, чтение файла, изменение файла. Это бэкдор для минималистов.

Все инструменты с одного завода

Обратите внимание на эти значения по умолчанию: isConcurrencySafe по умолчанию false, isReadOnly по умолчанию false.

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

Железный закон 'Чтение перед записью'

FileEditTool проверит, читали ли вы уже этот файл с помощью FileReadTool. Если нет, он сразу выдаст ошибку и не позволит внести изменения.

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

5. Третий секрет: система памяти — почему он может «помнить вас»

Любой, кто использовал Claude Code, чувствует: он кажется действительно знающим вас.

Вы говорите ему «не мокай базу данных в тестах», и он не будет мокать в следующем взаимодействии. Вы говорите «я бэкенд-инженер, новичок в React», и он объяснит фронтенд-код, используя аналогии бэкенда.

За этим стоит полноценная система памяти.

Использование ИИ для извлечения воспоминаний

Claude Code использует другой ИИ (Claude Sonnet), чтобы определить, «какие воспоминания относятся к текущему разговору»

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

Стратегия — «точность важнее полноты» — лучше пропустить потенциально полезное воспоминание, чем внедрить нерелевантное, загрязняя контекст.

Режим KAIROS: ночные «сновидения»

Это самая научно-фантастическая часть для меня.

В коде есть флаг функции под названием KAIROS. В этом режиме воспоминания из длинных разговоров хранятся не в структурированных файлах, а в записях, похожих на лог с добавлением даты. Затем есть навык /dream, который запускается «ночью» (низкая активность), дистиллируя эти сырые логи в структурированные тематические файлы.

ИИ организует воспоминания, пока «спит». Это уже не инженерия; это бионика.

6. Пятый секрет: это не агент, это группа

Когда вы заставляете Claude Code выполнить сложную задачу, он может тихо сделать это:

Он генерирует субагента.

И у субагента есть строгое внедрение «самосознания», чтобы предотвратить рекурсивную генерацию новых субагентов:

Этот кусок кода говорит: «Ты рабочий, а не менеджер. Не думай о найме других людей, делай работу сам».

Паттерн координатора: паттерн менеджера

В паттерне координатора Claude Code становится чистым оркестратором задач, не выполняя работу сам, а просто делегируя:

Основные принципы, написанные в комментариях к коду:

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

Оптимизация кэша промптов до предела

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

«Fork запущен — обработка в фоновом режиме»

Почему? Потому что кэш промптов API Claude основан на побайтовом сопоставлении префикса. Если байты префикса 10 субагентов идентичны, то только первый нуждается в «холодном старте», остальные 9 напрямую попадают в кэш.

Это оптимизация, которая экономит несколько центов за вызов, но в масштабе она может сэкономить значительную сумму затрат.

Семь, Шестой секрет: трехслойное сжатие для обеспечения диалогов, которые «никогда не превышают лимиты»

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

Claude Code разработал для этого трехслойное сжатие:

Слой 1: Микросжатие — минимальные затраты

Микросжатие затрагивает только старые результаты вызовов инструментов — заменяя «Содержимое 500-строчного файла, прочитанного 10 минут назад» на [Содержимое старого результата инструмента очищено].

Слова промпта и нить диалога полностью сохраняются.

Слой 2: Автосжатие — проактивное сокращение

Когда потребление токенов приближается к 87% окна контекста (размер окна - 13 000 буфер), срабатывает автоматически. Есть предохранитель: остановить попытки после 3 последовательных сбоев сжатия, чтобы избежать цикла.

Слой 3: Полное сжатие — суммаризация ИИ

Попросите ИИ сгенерировать резюме всего разговора, а затем замените все исторические сообщения этим резюме. При генерации резюме действует строгое предписание:

Почему так строго? Потому что если ИИ сделает дополнительные вызовы инструментов в процессе суммаризации, это повлечет за собой большее потребление токенов, что контрпродуктивно. Этот промпт по сути говорит: «Ваша задача — суммировать, больше ничего не делайте».

Бюджет сжатых токенов:

· Восстановление файлов: 50 000 токенов

· Лимит на файл: 5 000 токенов

· Содержимое навыков: 25 000 токенов

Эти числа не случайны — они представляют точку баланса между «сохранением достаточного контекста для продолжения работы» и «освобождением достаточного пространства для получения новых сообщений».

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

90% работы ИИ-агента находится вне «ИИ»

В 510 000 строк кода часть, фактически вызывающая API LLM, вероятно, составляет менее 5%. А что насчет оставшихся 95%?

· Проверки безопасности (18 файлов только для одного BashTool)

· Система прав доступа (разрешить/запретить/спросить/пропустить квадратичное решение)

· Управление контекстом (трехслойное сжатие + извлечение памяти ИИ)

· Восстановление после ошибок (предохранитель, экспоненциальная задержка, сохранение транскриптов)

· Координация мультиагентов (оркестрация роя + почтовое общение)

· Взаимодействие с UI (140 React-компонентов + мост IDE)

· Оптимизация производительности (стабильность кэша промптов + параллельная предварительная выборка при запуске)

Если вы создаете продукт ИИ-агента, это реальные проблемы, которые вам нужно решить. Дело не в том, насколько умна ваша модель; дело в том, насколько надежны ваши строительные леса.

Хороший промпт-инжиниринг — это системная инженерия

Речь не только о создании хорошего промпта. Промпты Claude Code включают:

· 7-слойную динамическую сборку

· Каждый инструмент поставляется с отдельным руководством пользователя

· Границы кэша точно очерчены

· Внутренние и внешние версии имеют разные наборы инструкций

· Порядок инструментов фиксирован для поддержания стабильности кэша

Это инженерное управление промптами, а не ремесленничество.

Дизайн для сбоев

У каждой внешней зависимости есть соответствующая политика сбоев:

Anthropic рассматривает Claude Code как операционную систему

42 инструмента = Система разрешений системных вызовов = Система навыков управления правами пользователя = Протокол MCP магазина приложений Protocol = Рой агентов драйверов устройств = Управление процессами Сжатие контекста = Управление памятью Сохранение транскриптов = Файловая система

Это не «чат-бот плюс несколько инструментов»; это операционная система с LLM в ядре.

Резюме

510 000 строк кода. 1903 файла. 18 файлов безопасности только для одного инструмента Bash.

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

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

И цена этой системы доверия — 510 000 строк кода.

Оригинальный пост