47 советов
по Claude Code

Строку статуса внизу окна Claude Code можно настроить так, чтобы она показывала полезное. У меня там модель, текущая папка, ветка git (если есть), количество незакоммиченных файлов, статус синхронизации с origin и полоска расхода токенов. Во второй строке — моё последнее сообщение, чтобы помнить, о чём вообще был разговор:

Opus 4.5 | 📁claude-code-tips | 🔀main (scripts/context-bar.sh uncommitted, synced 12m ago) | ██░░░░░░░░ 18% of 200k tokens
💬 This is good. I don't think we need to change the documentation as long as we don't say that the default color is orange el...

Особенно полезно, чтобы следить за расходом контекста и не забывать, над чем вы работали. Скрипт поддерживает 10 цветовых тем: orange, blue, teal, green, lavender, rose, gold, slate, cyan и gray.

Чтобы всё это настроить, возьмите готовый скрипт и посмотрите инструкцию по установке.

Встроенных слэш-команд много — наберите /, чтобы увидеть все. Вот те, что стоит знать.

/usage — проверить лимиты

 Current session
 █████████▌                                         19% used
 Resets 12:59am (America/Vancouver)

 Current week (all models)
 █████████████████████▌                             43% used
 Resets Feb 3 at 1:59pm (America/Vancouver)

 Current week (Sonnet only)
 ███████████████████▌                               39% used
 Resets 8:59am (America/Vancouver)

Если хотите следить за расходом внимательно, держите это открытым в отдельной вкладке и обновляйте через Tab, затем Shift+Tab, или ←, затем →.

/chrome — интеграция с браузером

Включает и выключает встроенную интеграцию Claude с Chrome.

/mcp — управление MCP-серверами

 Manage MCP servers
 1 server

 ❯ 1. playwright  ✔ connected · Enter to view details

 MCP Config locations (by scope):
  • User config (available in all your projects):
    • /Users/yk/.claude.json

/stats — статистика использования

Показывает график активности в стиле GitHub.

      Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec Jan
      ··········································▒█░▓░█░▓▒▒
  Mon ·········································▒▒██▓░█▓█░█
      ·········································░▒█▒▓░█▒█▒█
  Wed ········································░▓▒█▓▓░▒▓▒██
      ········································░▓░█▓▓▓▓█░▒█
  Fri ········································▒░░▓▒▒█▓▓▓█
      ········································▒▒░▓░░▓▒▒░░

      Less ░ ▒ ▓ █ More

  Favorite model: Opus 4.5        Total tokens: 17.6m

  Sessions: 4.1k                  Longest session: 20h 40m 45s
  Active days: 79/80              Longest streak: 75 days
  Most active day: Jan 26         Current streak: 74 days

  You've used ~24x more tokens than War and Peace

/clear — начать с чистого листа

Очищает диалог. Дальше — совет 5 о том, почему это стоит делать чаще, чем кажется.

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

На Mac я пробовал несколько вариантов:

• superwhisper
• MacWhisper
• Super Voice Assistant — открытый исходный код, поддерживает Parakeet v2/v3

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

Лучше всего думать об этом так: вы общаетесь с другом. Можно переписываться в мессенджере — кому-то так удобнее, кому-то ближе почта, и это нормально, большинство именно так с Claude Code и работает. Но если хочется быстрее — почему бы не созвониться? Никакого буквального звонка не нужно: просто шлите подряд голосовые. Для меня это быстрее, потому что я много лет тренировал навык говорить вслух. Но, думаю, для большинства это тоже окажется быстрее.

Типичное возражение: «а если я в комнате с другими людьми?» Я просто шепчу в наушники — мне нравятся Apple EarPods (не AirPods). Недорогие, качества хватает, и вы тихо шепчете в микрофон. Я делал так при других людях — всё отлично работает. В офисах люди и так разговаривают, просто вместо коллег вы тихо говорите со своей системой транскрипции. Метод работает настолько хорошо, что годится даже в самолёте: там достаточно шумно, чтобы соседи вас не слышали, но если говорить близко к микрофону, локальная модель всё разберёт. Собственно, этот абзац я и пишу таким способом на борту.

Это один из важнейших навыков. Он ровно такой же, как в классической разработке: лучшие инженеры уже умеют это делать, и к Claude Code это применимо один в один.

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

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

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

Просто поручайте Claude всю работу с Git и GitHub CLI: коммиты (не надо руками писать сообщения), ветки, pull и push.

Лично я разрешаю автоматический pull, но не push: push рискованнее, а неудачный pull хотя бы не портит origin.

С GitHub CLI (gh) можно делать очень многое. Одна привычка, которая появилась у меня именно из-за Claude Code, — чаще создавать черновые пул-реквесты (draft PR). Так Claude Code берёт на себя создание PR с минимальным риском: вы всё проверяете перед тем, как перевести его в ready for review.

И оказывается, gh весьма мощный. Через него можно отправлять произвольные GraphQL-запросы — например, узнать точное время каждой правки описания пул-реквеста:

⏺ Bash(gh api graphql -f query='
      query {
        repository(owner: "...", name: "...") {
          pullRequest(number: ...) {
            userContentEdits(first: 100) {
              nodes { editedAt editor { login } }
            }
          }
        }
      }')

⏺ Here's the full edit history for your PR description:

  | #  | Edited At (UTC)     | Editor |
  |----|---------------------|--------|
  | 1  | 2025-12-01 00:08:34 | ykdojo |
  | 2  | 2025-12-01 15:57:21 | ykdojo |
  | 3  | 2025-12-01 16:24:33 | ykdojo |
  | 4  | 2025-12-01 16:27:00 | ykdojo |
  | 5  | 2025-12-04 00:40:02 | ykdojo |
  ...

Как убрать подписи в коммитах и PR

По умолчанию Claude Code добавляет в коммиты трейлер Co-Authored-By, а в пул-реквесты — подпись в подвале. И то, и другое отключается в ~/.claude/settings.json:

{
  "attribution": {
    "commit": "",
    "pr": "",
    "sessionUrl": false
  }
}

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

sessionUrl — отдельный флаг (по умолчанию true): Claude Code также добавляет в коммиты трейлер Claude-Session: и ссылку на сессию в тело PR. Поставьте false, чтобы этого не было.

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

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

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

• Команда /copy — самый простой вариант: последний ответ Claude окажется в буфере обмена в виде markdown.
• Прямо в буфер обмена — на Mac или Linux попросите отправить вывод в буфер через pbcopy.
• Записать в файл — пусть Claude положит содержимое в файл, а потом откроет его в VS Code. Можно указать и номер строки, то есть попросить открыть ровно ту строку, которую он только что правил. Для markdown-файлов, открыв их в VS Code, нажмите Cmd+Shift+P (на Linux и Windows — Ctrl+Shift+P) и выберите «Markdown: Open Preview», чтобы увидеть отрендеренную версию.
• Открыть ссылку — если хотите сами посмотреть какой-то URL, попросите Claude открыть его в браузере. На Mac для этого есть команда open, но и просто «открой в моём браузере» сработает на любой платформе.
• GitHub Desktop — можно попросить открыть текущий репозиторий в нём. Особенно полезно, когда Claude работает не в корневой папке: например, если вы попросили создать git worktree в другой директории, а Claude Code оттуда ещё не запускали.

Эти способы комбинируются. Например, если нужно поправить описание пул-реквеста на GitHub, не давайте Claude редактировать его напрямую (может напортачить) — пусть сначала скопирует содержимое в локальный файл. Там он его правит, вы проверяете результат, и когда всё нравится, он копирует текст обратно в PR. Работает отлично. Или, если хотите вставить сами, попросите открыть файл в VS Code либо отдать текст через pbcopy.

Разумеется, все эти команды вы можете выполнять и сами. Но если делаете это раз за разом, проще отдать их Claude.

Из-за Claude Code я стал гораздо больше жить в терминале, и оказалось полезным завести короткие алиасы — сокращения для длинных команд. Вот мои:

• c — Claude Code, использую чаще всего
• ch — Claude Code с интеграцией Chrome
• cr — claude remote-control, поднять сервер, которым можно управлять с телефона
• gb — GitHub Desktop
• co — VS Code
• q — перейти в папку, где лежит большинство моих проектов. Оттуда я либо руками захожу в нужную папку, либо просто запускаю Claude Code через c, чтобы у него был доступ к любому проекту

Чтобы их настроить, добавьте такие строки в конфиг вашей оболочки (~/.zshrc или ~/.bashrc):

alias c='claude'
alias ch='claude --chrome'
alias cr='claude remote-control'
alias gb='github'
alias co='code'
alias q='cd ~/Desktop/projects'

С алиасами можно сразу комбинировать флаги: c -c продолжает последний диалог, а c -r показывает список недавних диалогов для возобновления. С ch это тоже работает (ch -c, ch -r) — для сессий с Chrome.

В Claude Code есть команда /compact, которая ужимает диалог в краткое изложение и освобождает место в контексте. Автоматическое сжатие срабатывает и само, когда весь доступный контекст заполнен. Общее контекстное окно у Opus 4.5 сейчас — 200k, и 45k из них зарезервировано под автосжатие. Ещё примерно 10% от этих 200k автоматически съедает системный промпт, инструменты, память и динамический контекст. Но я убедился, что лучше делать это заранее и настраивать вручную. Я отключил авто-компакт через /config, чтобы под основной диалог оставалось больше контекста, а у меня было больше контроля над тем, когда и как происходит сжатие.

Делаю я это так: прошу Claude написать документ-передачу (handoff) перед тем, как начать с чистого листа. Примерно такой формулировкой:

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

Claude создаст файл с описанием текущего состояния работы:

⏺ Write(experiments/system-prompt-extraction/HANDOFF.md)
  ⎿  Wrote 129 lines to experiments/system-prompt-extraction/HANDOFF.md
     # System Prompt Slimming - Handoff Document
     ## Goal
     Reduce Claude Code's system prompt by ~45% (currently at 11%, need ~34% more).
     ## Current Progress
     ### What's Been Done
     - **Backup/restore system**: `backup-cli.sh` and `restore-cli.sh` with SHA256 verification
     - **Patch system**: `patch-cli.js` that restores from backup then applies patches
     ...

После того как Claude его напишет, быстро пробегитесь глазами. Чего-то не хватает — попросите дописать:

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

Дальше начинайте новый диалог. Новому агенту можно дать только путь к файлу и больше ничего — этого достаточно:

> experiments/system-prompt-extraction/HANDOFF.md

В следующих диалогах просите агента обновлять этот документ для того, кто придёт после него.

Я также сделал слэш-команду /handoff, которая это автоматизирует: она проверяет, есть ли уже HANDOFF.md, читает его, если он есть, а потом создаёт или обновляет файл — с целью, прогрессом, что сработало, что нет, и следующими шагами. Она лежит в папке skills либо ставится вместе с плагином dx.

Альтернатива: режим планирования

Войти в него можно через /plan или Shift+Tab. Попросите Claude собрать весь нужный контекст и составить исчерпывающий план для следующего агента:

Я включил режим планирования. Перенеси сюда весь контекст, который
понадобится следующему агенту. У него не будет никакого другого
контекста, так что придётся быть довольно подробным.

Claude изучит кодовую базу, соберёт контекст и напишет детальный план. Когда он закончит, вы увидите примерно такие варианты:

Would you like to proceed?

❯ 1. Yes, clear context and auto-accept edits (shift+tab)
  2. Yes, auto-accept edits
  3. Yes, manually approve edits
  4. Type here to tell Claude what to change

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

Если вы хотите, чтобы Claude Code делал что-то автономно — например, гонял git bisect, — ему нужен способ проверять результат. Ключ в том, чтобы замкнуть цикл: написал код, запустил, посмотрел вывод, повторил.

Например, вы работаете над самим Claude Code и замечаете, что /compact перестал работать и выдаёт ошибку 400. Классический инструмент, чтобы найти коммит-виновник, — git bisect. Приятно, что Claude Code может прогнать bisect сам на себе, но ему нужен способ тестировать каждый коммит.

Для задач с интерактивными терминалами (а Claude Code как раз такой) подходит tmux. Схема такая:

1. Запустить tmux-сессию

2. Отправить в неё команды

3. Снять вывод

4. Проверить, что вывод такой, как ожидалось

Вот простой пример проверки того, что /context работает:

tmux kill-session -t test-session 2>/dev/null
tmux new-session -d -s test-session
tmux send-keys -t test-session 'claude' Enter
sleep 2
tmux send-keys -t test-session '/context' Enter
sleep 1
tmux capture-pane -t test-session -p

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

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

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

Креативные стратегии тестирования

Иногда придумывать способ замкнуть цикл приходится творчески. Например, если вы делаете веб-приложение, можно взять Playwright MCP, Chrome DevTools MCP или встроенную интеграцию Claude с браузером (через /chrome). Chrome DevTools я пока не пробовал, а вот Playwright и встроенную интеграцию — да. В целом Playwright работает лучше. Он ест много контекста, но окна в 200k обычно хватает на одну задачу или несколько небольших.

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

Со временем это, вероятно, улучшится, но пока для большинства задач, не завязанных на визуал, я бы выбрал Playwright. Встроенную интеграцию использую, только если нужен залогиненный сеанс без передачи паролей (она работает в вашем собственном профиле браузера) или если нужно именно визуально кликать по координатам.

Поэтому я держу встроенную интеграцию с браузером выключенной по умолчанию и включаю её через тот самый алиас ch.

Дополнительно можно попросить использовать ссылки из дерева доступности вместо координат. Вот что у меня написано в CLAUDE.md на этот счёт:

# Claude for Chrome

- Use `read_page` to get element refs from the accessibility tree
- Use `find` to locate elements by description
- Click/interact using `ref`, not coordinates
- NEVER take screenshots unless explicitly requested by the user

Из личного опыта: был случай, когда я работал над Python-библиотекой (Daft) и мне нужно было протестировать локально собранную версию в Google Colab. Проблема в том, что собрать Python-библиотеку с Rust-бэкендом прямо в Colab тяжело — толком не работает. Пришлось собирать пакет локально и вручную его загружать. Ещё я пробовал monkey patching — на короткой дистанции это неплохо работало, пока не собиралась полная сборка. Эти стратегии тестирования я придумал и реализовал в диалоге с Claude Code.

Другая ситуация: нужно было проверить кое-что на Windows, а Windows-машины у меня нет. CI-тесты в том же репозитории падали из-за проблем с Rust на Windows, а локально протестировать было нечем. Пришлось создать черновой PR со всеми изменениями и ещё один черновой PR с теми же изменениями плюс включением Windows-прогонов CI на не-main ветках. Я поручил всё это Claude Code, а потом тестировал прямо в CI на новой ветке.

Я повторяю это уже несколько лет: Cmd+A и Ctrl+A — лучшие друзья в мире ИИ. К Claude Code это тоже относится.

Иногда вы хотите дать Claude Code ссылку, а он не может её открыть. Может, это закрытая страница (не секретные данные, просто недоступная публично) или что-то вроде поста на Reddit, который Claude Code с трудом подтягивает. В таких случаях просто выделите всё, что видите, скопируйте и вставьте прямо в Claude Code. Приём на удивление мощный.

С выводом терминала это тоже отлично работает. Когда у меня есть вывод самого Claude Code или любого другого приложения в терминале, я делаю тот же фокус: выделить всё, скопировать, вставить обратно.

Некоторые страницы плохо поддаются «выделить всё» — но есть приёмы, чтобы сначала привести их в удобный вид. Например, в тредах Gmail нажмите «Печать всех», чтобы получить окно предпросмотра печати (сам диалог печати отмените). На этой странице все письма треда развёрнуты, и весь разговор выделяется чисто. А чтобы спросить что-то про видео на YouTube или получить его пересказ, нажмите «Показать расшифровку» и потом выделите всё.

Это работает с любым ИИ, не только с Claude Code.

Лично я написал собственное приложение для голосовой транскрипции с нуля на Swift. И собственную строку статуса — тоже с нуля, с помощью Claude Code, на bash.

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

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

Claude Code можно спрашивать о ваших прошлых диалогах — он поможет их найти и поискать по ним. История хранится локально в ~/.claude/projects/, имена папок формируются из пути проекта: слэши заменяются на дефисы.

Например, диалоги проекта из /Users/yk/Desktop/projects/claude-code-tips будут храниться здесь:

~/.claude/projects/-Users-yk-Desktop-projects-claude-code-tips/

Каждый диалог — это файл .jsonl. По ним можно искать обычными командами:

# Найти все диалоги, где упоминается "reddit"
grep -l -i "reddit" ~/.claude/projects/-Users-yk-Desktop-projects-*/*.jsonl

# Найти сегодняшние диалоги по теме
find ~/.claude/projects/-Users-yk-Desktop-projects-*/*.jsonl -mtime 0 -exec grep -l -i "keyword" {} \;

# Вытащить только сообщения пользователя из диалога (нужен jq)
cat ~/.claude/projects/.../conversation-id.jsonl | jq -r 'select(.type=="user") | .message.content'

Или просто спросите Claude Code напрямую: «О чём мы сегодня говорили насчёт X?» — и он сам поищет по истории.

Когда вы гоняете несколько экземпляров Claude Code, порядок в голове важнее любой технической обвязки вроде git worktrees. Я рекомендую держать одновременно максимум три-четыре задачи.

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

• Самая левая вкладка — постоянная, с моей системой голосовой транскрипции.
• Вторая — настройка Docker-контейнера.
• Третья — проверка занятого места на диске.
• Четвёртая — работа над инженерным проектом.
• Пятая, текущая — написание вот этого самого совета.

Если вы одновременно делаете несколько вещей в одном проекте и не хотите, чтобы они конфликтовали, git worktrees — отличное решение. Просто попросите Claude Code создать worktree и работать там: точный синтаксис вам знать не нужно.

Базовая идея: вы работаете над другой веткой в другой директории. По сути это ветка + папка.

Слой из git worktrees хорошо ложится поверх «каскадного» метода из предыдущего совета.

Что такое git worktrees

Git worktree — это обычная ветка git, которой выделили отдельную директорию.

То есть если вы работаете, скажем, с веткой main и feature-branch-1, то без worktrees вы можете работать с ними только по очереди: папка проекта в каждый момент времени переключена на одну ветку. А с worktree вы продолжаете работать с main в исходной папке проекта и одновременно работаете с feature-branch-1 в новой папке.

Когда вы ждёте долгую операцию — сборку Docker-образа или прогон CI на GitHub, — попросите Claude Code делать ручной экспоненциальный бэкофф: проверять статус с растущими интервалами сна. Минута, потом две, потом четыре и так далее. Программно в классическом смысле это не реализуется — ИИ делает это вручную, — но работает вполне неплохо.

Так агент может непрерывно следить за статусом и сообщит вам, когда всё будет готово.

Claude Code — прекрасный помощник и соавтор в письме. Я использую его так: сначала даю весь контекст о том, что именно пишу, а потом голосом проговариваю подробные инструкции. Так получается первый черновик. Если он недостаточно хорош, пробую ещё несколько раз.

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

Обычно, когда человек садится писать новый документ, он открывает Google Docs или Notion. Но сейчас я честно считаю, что самый эффективный путь — markdown.

Markdown был хорош ещё до ИИ, но именно с Claude Code — который очень силён в работе с текстом — его ценность выросла. Захотели написать пост в блог или в LinkedIn — просто поговорите с Claude Code, сохраните результат в markdown и дальше работайте с ним.

Обратное тоже работает. Если у вас есть текст со ссылками откуда-то ещё, скажем из Slack, вы его копируете. При вставке напрямую в Claude Code ссылки теряются. Но если сначала вставить текст в документ Notion, а потом скопировать уже оттуда, вы получите markdown, который Claude Code, конечно же, читает.

Изолированные окружения отлично подходят для сессий с --dangerously-skip-permissions, где не нужно подтверждать каждую мелочь. Можно просто дать агенту поработать самому какое-то время. Это удобно для исследований и экспериментов — долгих и, возможно, рискованных.

Есть два основных пути:

1. Запускать в контейнере

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

2. Отдать ему целую машину

   Можно пойти дальше и собрать машину, которой Claude Code управляет полностью, включая управление мышью и клавиатурой.

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

Продвинутое: воркер Claude Code в контейнере

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

1. Локальный Claude Code запускает tmux-сессию.
2. В этой сессии он запускает контейнер или подключается к нему.
3. Внутри контейнера Claude Code работает с --dangerously-skip-permissions.
4. Внешний Claude Code через tmux send-keys отправляет промпты, а через capture-pane читает вывод.

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

Продвинутое: оркестрация нескольких моделей

В контейнерах можно запускать не только Claude Code, но и другие ИИ-инструменты командной строки: Codex, Antigravity CLI и прочие. Я пробовал OpenAI Codex для ревью кода — работает хорошо. Суть не в том, что эти инструменты нельзя запустить прямо на своей машине — конечно, можно. Ценность в том, что интерфейс Claude Code достаточно удобен, чтобы вы просто разговаривали с ним, а он занимался оркестрацией: поднимал разные модели, гонял данные между контейнерами и вашим компьютером. Вместо ручного переключения между терминалами и копипаста Claude Code становится центральным интерфейсом, который всё координирует.

Недавно я смотрел интервью со скалолазкой мирового уровня, которое брал другой скалолаз. Её спросили: «Как стать лучше в скалолазании?» Она просто ответила: «Лазать».

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

Иногда хочется попробовать другой подход, отталкиваясь от конкретной точки диалога, но не потеряв исходную ветку. В Claude Code форк встроен:

• /branch — ответвляет текущую сессию прямо изнутри диалога
• --fork-session — используется вместе с --resume или --continue, например claude -c --fork-session

Короткой формы у --fork-session нет, поэтому можно добавить в ~/.zshrc или ~/.bashrc такую функцию и пользоваться сокращением --fs:

claude() {
  local args=()
  for arg in "$@"; do
    if [[ "$arg" == "--fs" ]]; then
      args+=("--fork-session")
    else
      args+=("$arg")
    fi
  done
  command claude "${args[@]}"
}

Она перехватывает все команды claude, разворачивает --fs в --fork-session, а всё остальное передаёт как есть. С алиасами из совета 7 тоже работает: c -c --fs, ch -c --fs.

Половинный клон, чтобы сократить контекст

Когда диалог становится слишком длинным, скрипт half-clone-conversation оставляет только вторую половину. Это снижает расход токенов, сохраняя вашу свежую работу. Первое сообщение помечается как [HALF-CLONE <timestamp>]. Есть и вариант «четверть» (--quarter либо скилл quarter-clone) — полезно, когда даже половина слишком много.

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

ln -s /path/to/this/repo/scripts/half-clone-conversation.sh ~/.claude/scripts/half-clone-conversation.sh
ln -s /path/to/this/repo/skills/half-clone ~/.claude/skills/half-clone
ln -s /path/to/this/repo/skills/quarter-clone ~/.claude/skills/quarter-clone

Или поставьте плагин dx — тогда симлинки не нужны.

Автопредложение half-clone через хук

По желанию можно повесить хук, который автоматически запускает /half-clone, когда контекст разрастается. Скрипт check-context выполняется после каждого ответа Claude и проверяет заполненность контекста. Если она выше 85%, скрипт говорит Claude выполнить /half-clone, и тот создаёт новый диалог только из второй половины.

Для настройки сначала скопируйте скрипт:

cp /path/to/this/repo/scripts/check-context.sh ~/.claude/scripts/check-context.sh
chmod +x ~/.claude/scripts/check-context.sh

Затем добавьте хук в ~/.claude/settings.json:

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "~/.claude/scripts/check-context.sh"
          }
        ]
      }
    ]
  }
}

Рекомендуемое разрешение для скрипта half-clone

Скрипту нужно читать ~/.claude — файлы диалогов и историю. Чтобы он не спрашивал разрешение из каждого проекта, добавьте это в глобальные настройки:

{
  "permissions": {
    "allow": ["Read(~/.claude)"]
  }
}

Когда нужно рассказать Claude Code о файлах в другой папке, получите полный путь через realpath:

realpath some/relative/path

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

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

Например, я собрал плагин dx, который объединяет скиллы из этого репозитория. Как он устроен — в совете 44.

Claude Code отлично подходит для ревью PR. Процедура простая: просите его получить информацию о пул-реквесте командой gh, а дальше проводите ревью так, как вам удобно.

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

Ключевое отличие в том, что Claude Code выступает интерактивным ревьюером, а не одноразовой машиной. Некоторые ИИ-инструменты хорошо делают ревью «в один заход», но с Claude Code можно вести диалог.

Claude Code великолепен в любом исследовании. По сути, это замена гуглу или deep research, только в нескольких отношениях мощнее. Разбираетесь ли вы, почему упали GitHub Actions, делаете анализ настроений или рынка по Reddit, изучаете свой код или ищете что-то в открытых источниках — он справится.

Главное — дать ему нужные куски информации и объяснить, как до них добраться. Это может быть доступ к команде gh в терминале, подход с контейнером (совет 19), Reddit через скилл reddit-fetch, приватная информация через MCP вроде Slack MCP или метод «выделить всё» (совет 10). Если Claude Code не может загрузить какие-то ссылки, попробуйте Playwright MCP или встроенную интеграцию с браузером (совет 9). Для научных исследований я сделал плагин paper-search — поиск по академическим статьям.

Более того, однажды мне удалось сэкономить 10 000 долларов, используя Claude Code для исследования.

Если речь о коде, один из способов — попросить написать тесты и убедиться, что они в целом выглядят разумно. Но можно и просто читать генерируемый код по ходу дела прямо в интерфейсе Claude Code. Ещё вариант — визуальный git-клиент, например GitHub Desktop: продукт не идеальный, но для быстрой проверки изменений его достаточно. И, конечно, черновой PR: пусть он его создаст, вы проверяете содержимое и только потом переводите в настоящий.

Я вынес это в отдельный совет, потому что для меня это оказалось потрясающе полезным. Всякий раз, когда падает CI на GitHub Actions, я просто отдаю это Claude Code и говорю: «разберись в проблеме, найди корневую причину». Иногда он выдаёт поверхностные ответы, но если продолжать спрашивать — это вызвано конкретным коммитом, конкретным PR или это плавающая ошибка? — он реально помогает докопаться до неприятных проблем, которые вручную разбирать больно. Пришлось бы перелопачивать кучу логов, а Claude Code берёт значительную часть этого на себя.

Я упаковал этот процесс в слэш-команду /gha: просто запустите /gha <url> с любой ссылкой на GitHub Actions, и она сама расследует падение, проверит на плавучесть, найдёт ломающие коммиты и предложит исправления. Она лежит в папке skills либо ставится вместе с плагином dx.

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

Важно держать CLAUDE.md простым и максимально лаконичным. Можно вообще начать без него. А когда заметите, что раз за разом повторяете Claude Code одно и то же, — вот тогда и добавьте это в CLAUDE.md. Для этого есть символ #, но лично я предпочитаю просто попросить Claude Code добавить нужное в CLAUDE.md уровня проекта или в глобальный — он сам разберётся, что именно править.

Ещё важно периодически пересматривать свои файлы CLAUDE.md — они устаревают. Инструкции, которые имели смысл когда-то, могут стать неактуальными, или у вас появились новые практики, которые стоит записать. Я сделал для этого скилл review-claudemd: он анализирует ваши недавние диалоги и предлагает улучшения.

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

Но есть и более общая правда: Claude Code — это по-настоящему универсальный интерфейс к вашему компьютеру, к цифровому миру, к любой цифровой задаче. Нужно быстро смонтировать видео — просто попросите, он сообразит сделать это через ffmpeg или что-то похожее. Нужно расшифровать пачку аудио- или видеофайлов — он может предложить Whisper через Python. Хотите проанализировать данные в CSV — он предложит Python или JavaScript для визуализации. А с доступом в интернет — Reddit, GitHub, MCP — возможности бесконечны.

Он же прекрасно подходит для операций на вашем компьютере. Например, если заканчивается место на диске, попросите совета, как его расчистить. Он пройдётся по вашим папкам, найдёт, что занимает больше всего, и подскажет, что делать. У меня так нашлись здоровенные файлы Final Cut Pro, которые давно надо было убрать. Может, он предложит подчистить неиспользуемые Docker-образы через docker system prune. А может, найдёт кэш, о существовании которого вы и не подозревали.

Забавно, ведь компьютер начинался с текстового интерфейса. И мы, в каком-то смысле, к нему возвращаемся — только теперь можно поднять три-четыре вкладки одновременно. Ощущение, будто у вас появился второй мозг. Но поскольку это всего лишь вкладка терминала, вы можете открыть и третий, и четвёртый, и пятый. А по мере того как модели становятся мощнее, растёт и доля мышления, которую можно им делегировать — не важные вещи, а те, которые вам не хочется делать, которые скучны или слишком муторны. Хороший пример — разбор GitHub Actions. Кто хочет этим заниматься? А агенты, оказывается, отлично справляются с такими скучными задачами.

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

Кто-то говорит, что вайб-кодинг — зло, потому что вы не понимаете, что делаете. Но иногда это совершенно нормально. А иногда полезно копнуть глубже, задействовать инженерные навыки, разобраться в коде детально или скопировать куски кода и конкретные логи ошибок, чтобы задать Claude Code точечные вопросы.

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

Авто-режим позволяет Claude самому решать, безопасна ли команда в данном контексте, вместо того чтобы просить у вас подтверждение на каждую. Переключиться на него можно через Shift+Tab. Я пользуюсь им уже какое-то время, и пока всё отлично.

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

{
  "permissions": {
    "defaultMode": "auto"
  }
}

Если хочется большей осторожности, вы всегда можете подтверждать всё вручную. А если нужна полная независимость — запускайте Claude Code в контейнере с --dangerously-skip-permissions.

Remote Control позволяет управлять Claude Code с телефона, и это отлично сочетается с авто-режимом: запустили задачу, ушли, а проверяете откуда угодно. Есть два способа.

Короткая форма первой команды — /rc. Сервер у меня заалиасен в cr, так что получается просто cr --spawn=worktree --capacity=N.

Документация: Remote Control.

Если вы делаете страницу на HTML, CSS и JavaScript, артефакт — отличный способ быстро посмотреть результат и даже поделиться им. Попросите Claude Code положить страницу в артефакт, и он опубликует её на claude.ai и даст вам ссылку.

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

Чем больше кода вы пишете с Claude Code, тем легче наделать ошибок. Ревью пул-реквестов и визуальные git-клиенты помогают их ловить, но по мере роста кодовой базы тесты становятся критичны.

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

Я убедился, что TDD — разработка через тестирование — отлично сочетается с Claude Code:

1. Сначала пишем тесты

2. Убеждаемся, что они падают

3. Коммитим тесты

4. Пишем код, чтобы тесты прошли

Написав сначала падающие тесты и закоммитив их до реализации, вы создаёте чёткий контракт: что именно код должен делать. У Claude Code появляется конкретная цель, а вы проверяете корректность реализации прогоном тестов.

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

С тех пор как я стал плотно работать с Claude Code, я заметил, что становлюсь всё смелее в незнакомых областях.

Например, когда я пришёл в Daft, я заметил проблему в нашем фронтенд-коде. Я не эксперт в React, но всё равно решил разобраться. Просто начал задавать вопросы про кодовую базу и про саму проблему. В итоге я её решил, потому что умел итеративно решать задачи вместе с Claude Code.

Похожее случилось недавно. Я делал руководство для пользователей Daft и наткнулся на очень специфические проблемы: cloudpickle не работал в Google Colab вместе с Pydantic, и отдельно — проблема на стыке Python и Rust, где вывод некорректно печатался в JupyterLab, хотя в терминале всё было нормально. С Rust я до этого никогда не работал.

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

Дальше был совместный итеративный процесс. Claude Code предлагал возможные причины и решения. Я их проверял. Часть оказалась тупиковой — тогда мы шли в другую сторону. Всё это время я управлял темпом. Где-то ускорялся — например, когда давал ему исследовать разные варианты. Где-то замедлялся и спрашивал: «а что именно означает вот эта строка?» Управлял уровнем абстракции, управлял скоростью.

В итоге я нашёл довольно изящное решение. Вывод: даже на незнакомой территории с Claude Code вы можете гораздо больше, чем вам кажется.

Если в Claude Code выполняется долгая команда, нажмите Ctrl+B, чтобы отправить её в фон. Claude Code умеет управлять фоновыми процессами и позже сам проверит результат.

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

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

Как использовать субагентов с умом

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

• Сколько — попросите Claude запустить нужное вам количество.
• Фон или передний план — попросите запустить их в фоне или нажмите Ctrl+B.
• Какая модель — попросите Opus, Sonnet или Haiku в зависимости от сложности конкретной задачи. По умолчанию у субагентов Sonnet.

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

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

Ещё пример: korotovsky/slack-mcp-server — популярный Slack MCP почти с 1000 звёзд — рассчитан на запуск в Docker-контейнере. Мне было неудобно использовать его внутри моего собственного контейнера. Вместо того чтобы бороться с этим, я просто попросил Claude Code написать инструмент напрямую через Node SDK от Slack. Получилось отлично.

Что бы вы ни хотели сделать — попросите Claude Code. Если задача небольшая, вы соберёте это за час-два. Я даже сделал шаблон презентации — один HTML-файл с CSS и JavaScript, в который можно встроить живой терминал.

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

Навигация

• Ctrl+A — в начало строки
• Ctrl+E — в конец строки
• Option+←/→ на Mac или Alt+←/→ — по словам назад и вперёд

Редактирование

• Ctrl+W — удалить предыдущее слово
• Ctrl+U — удалить от курсора до начала строки
• Ctrl+K — удалить от курсора до конца строки
• Ctrl+C или Ctrl+L — очистить текущий ввод
• Ctrl+G — открыть промпт во внешнем редакторе. Удобно для длинного текста: вставка напрямую в терминал бывает медленной

Для Ctrl+G редактор определяется переменной окружения EDITOR. Задать её можно в конфиге оболочки:

export EDITOR=vim      # или nano, code, nvim и т. д.

Или в настройках — тогда нужен перезапуск:

{
  "env": {
    "EDITOR": "vim"
  }
}

Перенос строки и картинки

Самый быстрый способ сделать перенос строки работает везде и без настройки: наберите \ и нажмите Enter. Для горячих клавиш выполните /terminal-setup. В Terminal.app на Mac я использую Option+Enter — но он работает только после включения «Use Option as Meta key» в Terminal → Settings → Profiles → Keyboard.

Картинка из буфера обмена вставляется через Ctrl+V на Mac и Linux или Alt+V на Windows. На Mac это именно Ctrl, а не Cmd.

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

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

Например, недавно я экспериментировал с просмотрщиком изменений в коде. Сначала попробовал простой прототип на tmux и lazygit, потом попытался сделать собственный на Ink и Node. Намучился и в итоге не опубликовал ни один из результатов. Но этот проект напомнил мне о важности планирования: если чуть лучше спланировать в начале, направлять работу получается заметно легче.

Для этого можно использовать режим планирования — переключиться в него через Shift+Tab. Или просто попросить Claude Code составить план перед тем, как писать код.

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

Поэтому иногда стоит просмотреть код и попросить всё упростить. Можно поправить самому, а можно просто попросить упростить. Полезно задавать вопросы вроде «почему ты внёс именно это изменение?» или «зачем ты добавил эту строку?».

Кто-то говорит, что если писать код только через ИИ, вы никогда его не поймёте. Но это верно только если вы не задаёте достаточно вопросов. Если следить за тем, что понимаете каждую деталь, вы на самом деле разберётесь в коде быстрее, чем иначе, — потому что можете спросить у ИИ.

В конечном счёте всё сводится к автоматизации автоматизации. Это лучший способ не просто стать продуктивнее, но и сделать сам процесс интереснее.

Лично я начинал с ChatGPT и хотел автоматизировать копипаст и запуск команд, которые он мне выдавал. Я автоматизировал весь этот процесс, написав плагин для ChatGPT под названием Kaguya. С тех пор я последовательно двигался ко всё большей автоматизации.

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

Потом я начал замечать, что иногда повторяю сам себя. Такие вещи я стал класть в CLAUDE.md. Потом подумал: окей, а некоторые команды я запускаю раз за разом. Как это автоматизировать? Может, попросить Claude Code. Может, положить в скиллы. А может, вообще попросить написать скрипт.

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

Этот совет немного выбивается из остальных. Изучая как можно больше, вы получаете возможность делиться знаниями с окружающими. Может, через посты вроде этого, может, даже через книги, курсы, видео. Недавно я провёл внутреннюю сессию для коллег в Daft. Это очень благодарное занятие.

И всякий раз, когда я делюсь советами, я получаю информацию в ответ. Например, я рассказал про разницу между слэш-командами и скиллами (совет 23) — и узнал новое из комментариев. Так что делиться знаниями — это не только про личный бренд. Улица не всегда с односторонним движением.

Что до вклада: я отправлял сообщения об ошибках в репозиторий Claude Code. Думал так: услышат — здорово, не услышат — тоже нормально. Но в версии 2.0.67 я заметил, что несколько моих предложений взяли в работу: починили сброс позиции прокрутки после удаления правила в /permissions и добавили туда поиск.

Удивительно, как быстро команда реагирует. Хотя это логично: они делают Claude Code с помощью самого Claude Code.

• Спросите сам Claude Code — если у вас вопрос про Claude Code, просто задайте его ему. У него есть специальный субагент, который отвечает на вопросы о собственных возможностях, командах, настройках, хуках и MCP-серверах.
• Читайте release notes — наберите /release-notes, чтобы увидеть, что нового в вашей версии. Это лучший способ узнавать о свежих возможностях.
• Учитесь у сообщества — сабреддит r/ClaudeAI хорош, чтобы смотреть, кто как выстраивает работу.
• Следите за Ado — @adocomplete, DevRel в Anthropic, весь декабрь 2025 года публиковал ежедневные советы в серии «Advent of Claude». Серия закончилась, но он продолжает делиться полезным.

Архивы серии: в X и в LinkedIn.

Репозиторий с оригиналом этих советов одновременно является плагином для Claude Code под названием dx (developer experience). Он собирает инструменты из советов выше в одну установку.

claude plugin marketplace add ykdojo/claude-code-tips
claude plugin install dx@ykdojo

После установки команды доступны как /dx:half-clone, /dx:handoff и /dx:gha. Скилл reddit-fetch вызывается автоматически, когда вы спрашиваете про ссылки на Reddit. Для команды half-clone см. рекомендуемое разрешение.

Рекомендуемое дополнение — Playwright MCP для автоматизации браузера:

claude mcp add -s user playwright npx @playwright/mcp@latest

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

На macOS ваш логин хранится в одной записи Keychain, но переменная окружения CLAUDE_CODE_OAUTH_TOKEN её перекрывает — так что можно запускаться от имени конкретного аккаунта. Переменная работает и на Linux, и на Windows: там логин лежит в ~/.claude/.credentials.json. Ниже пример для Mac — адаптируйте под свою систему.

Выпустите годовой токен для каждого аккаунта (claude setup-token откроет браузер — залогиньтесь в нужный аккаунт), а затем положите каждый токен в Keychain, чтобы он не лежал открытым текстом в ваших конфигах:

claude setup-token   # залогиньтесь под каждым аккаунтом, скопируйте токен
security add-generic-password -s "claude-token-work"     -a "$USER" -U -w
security add-generic-password -s "claude-token-personal" -a "$USER" -U -w

Добавьте в ~/.zshrc две функции, которые достают токен и передают все аргументы в claude:

clw() { CLAUDE_CODE_OAUTH_TOKEN="$(security find-generic-password -s claude-token-work     -a "$USER" -w)" claude "$@"; }
clp() { CLAUDE_CODE_OAUTH_TOKEN="$(security find-generic-password -s claude-token-personal -a "$USER" -w)" claude "$@"; }

Теперь clw и clp запускаются от имени соответствующих аккаунтов (например, clw --resume), а обычный claude по-прежнему использует логин из Keychain. Токены живут около года, так что для обновления просто повторите setup-token.

Этого раздела нет в оригинале — он добавлен в переводе для тех, кто открыл терминал недавно.

Контекст, контекстное окно

Объём текста, который модель держит «в голове» за один разговор. У Opus 4.5 это 200 тысяч токенов. Заполнился — качество ответов падает, поэтому диалоги начинают заново.

Токен

Кусочек текста примерно в половину слова. В токенах меряют и объём контекста, и стоимость работы модели.

Промпт

То, что вы пишете модели: задание вместе с пояснениями и примерами.

Слэш-команда

Команда, которая начинается со знака / и запускает заранее заготовленную инструкцию: /usage, /compact, /handoff.

Скилл

Папка с инструкцией для Claude, которую он подгружает сам, когда задача подходит. Отличается от CLAUDE.md тем, что не занимает место в контексте, пока не понадобится.

Плагин

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

Хук

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

MCP

Способ подключить к Claude внешний источник данных или инструмент: браузер, Slack, базу. Каждый такой источник — отдельный MCP-сервер.

Субагент

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

Артефакт

Опубликованная на claude.ai самодостаточная страница со ссылкой. Видна только вам, пока вы не поделитесь.

Репозиторий, коммит, ветка

Репозиторий — папка проекта под управлением git. Коммит — сохранённое состояние с описанием, что изменилось. Ветка — параллельная линия правок, чтобы не ломать основную версию.

PR, пул-реквест

Заявка «влейте мои изменения в основную ветку». Черновой (draft) PR — та же заявка, но помеченная как «ещё не готово к проверке».

CI, GitHub Actions

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

Git worktree

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

Контейнер, Docker

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

tmux

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

Алиас

Короткое имя для длинной команды: набрали c — запустился claude.

TDD

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

Экспоненциальный бэкофф

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