Claude Code Tips

by ykdojo (community) · Claude Code

Skill AI Assistants Open Source v0.26.34 · 22.08.2026 активный

45+ советов по эффективному использованию Claude Code — от основ до продвинутых техник, включая кастомный статус-лайн скрипт и запуск Claude Code в контейнере. Включает плагин dx: навыки для повседневных dev-задач.

GitHub
productivity ai-assistants claude-code skills
Версии
v0.26.34
22.08.2026 current
AI Assistants
Похожие инструменты
Claude Code Terminal Title
AI Assistants

Автоматически обновляет заголовки окон терминала на основе задач Claude Code — больше не нужно гадать, какой …
Google Workspace CLI Skill
AI Assistants

SKILL.md-инструкция для AI-агентов: работа с Google Workspace из терминала — Gmail, Calendar, Docs, Sheets, Drive через …
Superpowers
AI Assistants

Фреймворк агентных навыков и методология разработки ПО для Claude Code — набор SKILL.md-инструкций, охватывающих полный цикл …
GH Issues Auto-Fixer
AI Assistants

SKILL.md-инструкция для AI-агентов: автоматическое закрытие GitHub issues. 6-фазный воркфлоу: фильтрация issues → проверка веток → параллельный …

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

показать оригинал переведено ИИ

45+ советов по Claude Code: от основ до продвинутого уровня

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

📺 Быстрая демонстрация — посмотрите, как некоторые из этих советов работают в мульти-Claude рабочем процессе и с голосовым вводом:

Demo video thumbnail

Содержание

Совет 0: Настройте свою строку состояния

Вы можете настроить строку состояния в нижней части 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 цветовых тем (оранжевая, синяя, бирюзовая, зелёная, лавандовая, розовая, золотая, грифельная, голубая или серая).

Color preview options

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

Совет 1: Выучите несколько основных слэш-команд

Существует множество встроенных слэш-команд (введите /, чтобы увидеть их все). Вот несколько, которые стоит знать:

/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
Chrome integration enabled

/mcp

Управление серверами MCP (Model Context Protocol):

 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

Очищает беседу и позволяет начать заново.

Совет 2: Общайтесь с Claude Code голосом

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

На своём Mac я попробовал несколько разных вариантов: - superwhisper - MacWhisper - Super Voice Assistant (открытый исходный код, поддерживает Parakeet v2/v3)

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

Например, на этом скриншоте видно, что Claude смог правильно интерпретировать неверно распознанные слова вроде "ExcelElanishMark" и "advast" как "exclamation mark" («восклицательный знак») и "Advanced" («Расширенный»):

Voice transcription mistakes interpreted correctly

Мне кажется, что лучше всего подходить к этому так, словно вы пытаетесь пообщаться с другом. Конечно, вы можете общаться текстовыми сообщениями. Для некоторых это может быть проще, или же через электронную почту, верно? Это совершенно нормально. Именно так, судя по всему, большинство людей и работают с Claude Code. Но если вы хотите общаться быстрее, почему бы не устроить короткий разговор по телефону? Вы можете просто отправлять голосовые сообщения. Вам не нужно буквально устраивать телефонный звонок с Claude Code. Просто отправьте несколько голосовых сообщений подряд. Это быстрее, по крайней мере для меня — человека, который за последние годы немало практиковал искусство речи. Но я думаю, что и для большинства людей это будет быстрее. Распространённое возражение: «а что, если вы находитесь в комнате с другими людьми?» Я просто шепчу, используя наушники — лично мне нравятся Apple EarPods (не AirPods). Они недорогие, достаточно высокого качества, и вы просто тихо шепчете в них. Я делал это перед другими людьми, и это хорошо работает. В офисах люди и так разговаривают — вместо того чтобы общаться с коллегами, вы тихо говорите со своей системой голосового распознавания. Я не думаю, что в этом есть какая-то проблема. Этот метод работает настолько хорошо, что работает даже в самолёте. Он достаточно тихий, чтобы другие люди вас не услышали, но если говорить достаточно близко к микрофону, ваша локальная модель всё равно сможет понять, что вы говорите. (На самом деле, я пишу этот самый абзац, используя этот метод во время полёта.)

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

Совет 3: Разбивайте большие задачи на меньшие

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

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

По сути, вместо того чтобы идти от А к Б:

Direct approach

Вы можете пойти от А к А1 к А2 к А3, а затем к Б:

Step-by-step approach

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

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

Совет 4: Используйте Git и GitHub CLI как профессионал

Просто попросите Claude заняться вашими задачами в Git и GitHub CLI. Сюда входит создание коммитов (так вам не придётся писать сообщения коммитов вручную), ветвление, извлечение (pull) и отправка (push).

Лично я разрешаю автоматическое извлечение (pull), но не отправку (push), потому что отправка рискованнее — если что-то пойдёт не так с извлечением, это не испортит удалённый репозиторий (origin).

Для GitHub CLI (gh) можно сделать много всего. Одна вещь, которую я начал делать чаще после использования Claude Code, — это создание черновиков PR. Это позволяет Claude Code взять на себя процесс создания PR с низким риском — вы можете всё проверить, прежде чем помечать его готовым к ревью.

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

⏺ 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 в коммиты и сноску с указанием авторства в PR. Вы можете отключить и то, и другое, добавив это в ~/.claude/settings.json:

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

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

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

Совет 5: Контекст ИИ подобен молоку; лучше всего он подаётся свежим и сгущённым!

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

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

Совет 6: Как получить вывод из вашего терминала

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

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

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

Конечно, вы можете выполнять эти команды сами, но если вы замечаете, что делаете это постоянно, полезно позволить Claude выполнять их за вас.

Совет 7: Настройте псевдонимы терминала для быстрого доступа

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

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

Совет 8: Активно сжимайте свой контекст

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

То, как я это делаю — я прошу Claude написать документ передачи перед началом с чистого листа. Что-то вроде:

Помести оставшуюся часть плана в папку 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 видит только план, поэтому может сосредоточиться на задаче без багажа старого разговора. Кроме того, он получает ссылку на файл старого транскрипта на случай, если понадобятся какие-то конкретные детали.

Совет 9: Замыкай цикл «написать–протестировать» для автономных задач

Если ты хочешь, чтобы 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 и встроенную интеграцию Claude. В целом Playwright обычно работает лучше. Правда, он потребляет много контекста, но окна контекста в 200k обычно хватает на одну задачу или несколько небольших задач.

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

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

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

Кроме того, вы можете попросить его использовать ссылки на дерево доступности вместо координат. Вот что я добавил в свой 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-бэкендом в Google Colab довольно сложно — там это работает не слишком хорошо. Поэтому мне нужно было действительно собрать wheel локально, а затем загрузить его вручную, чтобы запустить его в Google Colab. Я также пробовал monkey patching, что хорошо сработало в краткосрочной перспективе, пока мне не пришлось дожидаться полной локальной сборки wheel. Я придумал эти стратегии тестирования и реализовал их, взаимодействуя с Claude Code туда-сюда.

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

Совет 10: Cmd+A и Ctrl+A — ваши друзья

Уже несколько лет я говорю, что Cmd+A и Ctrl+A — друзья в мире ИИ. Это относится и к Claude Code.

Иногда вы хотите дать Claude Code ссылку, но он не может получить к ней прямой доступ. Возможно, это закрытая страница (не секретные данные, просто недоступная публично) или что-то вроде поста на Reddit, который Claude Code сложно загрузить. В таких случаях вы можете просто выделить весь видимый контент (Cmd+A на Mac, Ctrl+A на других платформах), скопировать его и вставить напрямую в Claude Code. Это довольно мощный метод.

Это отлично работает и для вывода терминала. Когда у меня есть вывод от самого Claude Code или любого другого CLI-приложения, я могу использовать тот же трюк: выделить всё, скопировать и вставить обратно в CC. Довольно полезно.

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

Это относится к любому ИИ, а не только к Claude Code.

Совет 11: Инвестируйте в свой собственный рабочий процесс

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

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

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

Совет 12: Ищите в истории ваших бесед

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

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

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

Каждая беседа представляет собой файл .jsonl. Вы можете выполнять поиск по ним с помощью базовых команд bash:

# Find all conversations mentioning "Reddit"
grep -l -i "reddit" ~/.claude/projects/-Users-yk-Desktop-projects-*/*.jsonl

# Find today's conversations about a topic
find ~/.claude/projects/-Users-yk-Desktop-projects-*/*.jsonl -mtime 0 -exec grep -l -i "keyword" {} \;

# Extract just the user messages from a conversation (requires jq)
cat ~/.claude/projects/.../conversation-id.jsonl | jq -r 'select(.type=="user") | .message.content'

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

Совет 13: Многозадачность с помощью вкладок терминала

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

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

Вот как обычно выглядит моя настройка:

Terminal tabs showing multitasking workflow

В этом примере: 1. Крайняя левая вкладка - постоянная вкладка, на которой запущена моя система голосовой транскрипции (всегда находится здесь) 2. Вторая вкладка - настройка Docker-контейнера 3. Третья вкладка - проверка использования диска на моём локальном компьютере 4. Четвёртая вкладка - работа над инженерным проектом 5. Пятая вкладка (текущая) - написание этого самого совета

Совет 14: Git worktrees для параллельной работы с ветками

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

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

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

Что такое git worktrees?

Git worktree — это то же самое, что и любая другая ветка git, но с новой директорией, специально назначенной для неё.

Итак, если вы работаете, скажем, на ветке main и feature-branch-1, то без git worktrees вы можете работать над ними только поочередно, поскольку ваша папка проекта может быть настроена только на одну ветку за раз.

Однако с git worktree вы можете продолжать работать на ветке main (или на любой другой ветке) в исходной папке проекта и одновременно работать на feature-branch-1 в новой папке.

Git worktrees diagram showing parallel branch work in separate directories

Совет 15: Ручное экспоненциальное откладывание для длительных задач

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

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

(В частности, для GitHub CI существует команда gh run watch, но она непрерывно выводит много строк, что расходует токены. Ручное экспоненциальное откладывание с помощью gh run view <run-id> | grep <job-name> на самом деле более эффективно с точки зрения расхода токенов. Это также общая техника, которая хорошо работает даже тогда, когда под рукой нет специальной команды ожидания.)

Например, если у вас сборка Docker запущена в фоновом режиме:

Manual exponential backoff checking Docker build progress

И это продолжается до тех пор, пока задача не будет завершена.

Совет 16: Claude Code как помощник в написании текстов

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

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

Итак, это своего рода процесс обратной связи, возможно, с терминалом слева и вашим редактором кода справа:

Side-by-side writing workflow with Claude Code

Это, как правило, работает очень хорошо.

Совет 17: Markdown — это чертовски круто

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

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

Быстрый совет по этому поводу: если вы хотите скопировать и вставить содержимое markdown на платформу, которая не принимает его легко, вы можете сначала вставить его в новый файл Notion, а затем скопировать из Notion на другую платформу. Notion конвертирует его в формат, который другие платформы могут принять. Если обычная вставка не работает, попробуйте Command + Shift + V, чтобы вставить без форматирования.

Совет 18: Сохраняйте ссылки при вставке

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

Кроме того, вы можете просто попросить Claude Code прочитать ваш буфер обмена. Обычно он точно знает, какую команду использовать — на Mac это pbpaste — и может использовать эту команду для получения содержимого без изменения форматирования.

Совет 19: Изолированные среды для длительных и рискованных задач

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

Существуют два основных способа сделать это:

  1. Вы можете запустить его в контейнере. Я даже создал готовую среду, чтобы упростить запуск контейнеризированных сессий Claude Code.
  2. Вы можете зайти на шаг дальше, настроив целую машину, которой Claude Code может полностью управлять, включая использование компьютера.

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

Продвинутый уровень: Оркестрация рабочего экземпляра Claude Code в контейнере

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

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

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

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

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

Совет 20: Лучший способ улучшить навыки использования Claude Code — это использовать его

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

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

Мне нравится думать об этом как о правиле «миллиарда токенов» вместо правила «10 000 часов». Если вы хотите стать лучше в ИИ и действительно получить хорошую интуицию о том, как он работает, лучший способ — потреблять много токенов. И в наши дни это возможно. Я обнаружил, что особенно с Opus 4.5 он достаточно мощный, но при этом доступный, чтобы вы могли запускать несколько сессий одновременно. Вам не нужно так сильно беспокоиться об использовании токенов, что дает вам большую свободу.

Совет 21: Разветвление и половинное клонирование бесед

Иногда вы хотите попробовать другой подход с определенной точки в беседе, не теряя исходную цепочку. В 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>] (например, [HALF-CLONE Jan 7 14:30]). Также существует вариант четверть-клонирования (--quarter или навык quarter-clone), который сохраняет только последнюю четверть, помеченную тегом [QUARTER-CLONE <timestamp>] — полезно, когда даже половины слишком много.

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

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, когда ваш контекст становится слишком длинным. Скрипт 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"
          }
        ]
      }
    ]
  }
}

Для этого требуется отключить авто-уплотнение (auto-compact) (/config > Auto-compact > false), иначе Claude Code может уплотнить контекст до того, как хук успеет сработать. Когда хук срабатывает, он блокирует остановку Claude и говорит ему запустить /half-clone. Преимущество перед авто-уплотнением в том, что половинное клонирование детерминировано и быстро — оно сохраняет ваши реальные сообщения нетронутыми вместо их суммирования.

Рекомендуемые разрешения для скрипта половинного клонирования

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

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

Совет 22: Используйте realpath для получения абсолютных путей

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

realpath some/relative/path

Совет 23: Понимание CLAUDE.md, навыков, slash-команд и плагинов

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

CLAUDE.md — самая простая из них. Это набор файлов, которые воспринимаются как промпт по умолчанию, загружаемый в начало каждого разговора независимо ни от чего. Приятная особенность — простота. Вы можете описать, о чём проект, в конкретном проекте (./CLAUDE.md) или глобально (~/.claude/CLAUDE.md).

Навыки (Skills) — это как лучше структурированные файлы CLAUDE.md. Они могут вызываться Claude автоматически, когда это уместно, или вручную пользователем с помощью слэша (например, /my-skill). Например, вы могли бы создать навык, который открывает ссылку Google Translate с правильным форматированием, когда вы спрашиваете, как произносится слово на определённом языке. Если эти инструкции находятся в навыке, они загружаются только при необходимости. Если бы они были в CLAUDE.md, они уже занимали бы место. Поэтому навыки теоретически более эффективны с точки зрения расхода токенов.

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

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

Плагины — это способ упаковать вместе навыки, slash-команды, агентов, хуки и MCP-серверы. Но плагин не обязан использовать их все. Официальный плагин Anthropic frontend-design по сути является просто навыком и ничем больше. Он мог бы распространяться как отдельный навык, но формат плагина упрощает установку.

Например, я создал плагин под названием dx, который объединяет навыки из этого репозитория. Вы можете посмотреть, как он работает, в разделе Установка плагина dx.

Совет 24: Интерактивные проверки PR

Claude Code отлично подходит для проверки PR. Процедура довольно проста: вы просите его получить информацию о PR с помощью команды gh, а затем можете проводить проверку как хотите.

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

Ключевое отличие в том, что Claude Code выступает как интерактивный рецензент PR, а не просто одноразовая машина. Некоторые ИИ-инструменты хороши в одноразовых проверках (включая последние модели GPT), но с Claude Code вы можете вести беседу.

Совет 25: Claude Code как инструмент для исследований

Claude Code потрясающе подходит для любых исследований. По сути, это замена Google или замена глубоким исследованиям, но более продвинутая в нескольких разных аспектах. Будь то исследование того, почему определённые GitHub Actions завершились неудачей (чем я много занимался в последнее время), анализ тональности или рынка на Reddit, изучение вашей кодовой базы или поиск чего-либо в публичной информации — он способен на это.

Ключ в том, чтобы дать ему правильные фрагменты информации и инструкции о том, как получить доступ к этим фрагментам информации. Это может быть доступ к терминальной команде gh, или подход с контейнером (Совет 19), или Reddit через навык reddit-fetch, или приватная информация через MCP вроде Slack MCP, или метод Cmd+A / Ctrl+A (Совет 10) — что угодно. Кроме того, если Claude Code не удаётся загрузить определённые URL, вы можете попробовать использовать Playwright MCP или встроенную браузерную интеграцию Claude (см. Совет 9). Для научных исследований я создал плагин paper-search для поиска академических работ.

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

Совет 26: Освоение различных способов проверки его вывода

Один из способов проверить его вывод, если это код, — попросить его написать тесты и убедиться, что тесты в целом выглядят хорошо. Это один из способов, но вы, конечно, можете проверять сгенерированный им код по ходу дела прямо в интерфейсе Claude Code. Кроме того, вы можете использовать визуальный Git-клиент, например, GitHub Desktop. Я лично им пользуюсь. Это не идеальный продукт, но его вполне достаточно для быстрой проверки изменений. И, как я, вероятно, упоминал ранее в этом посте, отличным способом также является поручение ему создать PR. Пусть он создаст черновик PR, проверьте содержимое, прежде чем превращать его в реальный PR.

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

Совет 27: Claude Code как DevOps-инженер

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

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

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

Совет 28: Держите CLAUDE.md простым и периодически пересматривайте его

Важно держать CLAUDE.md простым и максимально лаконичным. Вы можете просто начать вообще без файла CLAUDE.md. И если вы заметите, что постоянно говорите Claude Code одно и то же снова и снова, то можете просто добавить это в CLAUDE.md. Я знаю, что есть опция сделать это через символ #, но я предпочитаю просто попросить Claude Code добавить это либо в CLAUDE.md уровня проекта, либо в глобальный CLAUDE.md, и он точно будет знать, что редактировать.

Keep it simple meme

Также важно периодически пересматривать свои файлы CLAUDE.md, потому что со временем они могут устаревать. Инструкции, которые имели смысл какое-то время назад, могут перестать быть актуальными, или у вас могут появиться новые шаблоны, которые следует задокументировать. Для этого я создал навык под названием review-claudemd, который анализирует ваши недавние беседы и предлагает улучшения для ваших файлов CLAUDE.md.

Совет 29: Claude Code как универсальный интерфейс

Раньше я думал, что с Claude Code CLI — это как новая IDE, и в некотором роде это до сих пор верно. Я думаю, это отличное место, где стоит открыть свой проект, когда вы хотите сделать быстрые правки и тому подобное. Но в зависимости от серьезности вашего проекта, вы захотите быть более внимательным к результатам, чем просто оставаясь на уровне «vibe coding». Но также верно, и это более общий случай, что Claude Code — по сути универсальный интерфейс к вашему компьютеру, цифровому миру, любой цифровой проблеме, которая у вас есть. Во многих случаях вы можете позволить ему разобраться с ней самостоятельно. Например, если вам нужно быстро отредактировать видео, вы можете просто попросить его сделать это — скорее всего, он поймёт, как это сделать через ffmpeg или что-то подобное. Если вы хотите расшифровать кучу аудиофайлов или видеофайлов, которые есть у вас локально, вы можете просто попросить его сделать это — он может предложить использовать Whisper через Python. Если вы хотите проанализировать данные, которые у вас есть в CSV-файле, он может предложить использовать Python или JavaScript для их визуализации. И конечно, с доступом в интернет — Reddit, GitHub, MCPs — возможности безграничны.

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

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

Совет 30: Всё дело в выборе правильного уровня абстракции

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

Vibe coding spectrum

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

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

Совет 31: Используйте авторежим

Авторежим позволяет Claude решать, безопасно ли выполнять команду в контексте, вместо того чтобы просить вас одобрить каждую по отдельности. (Вы можете переключиться в него с помощью shift+tab.) Я использую его уже некоторое время, и пока всё работает очень хорошо.

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

Чтобы сделать его режимом по умолчанию, добавьте это в ~/.claude/settings.json:

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

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

Обратите внимание, что авторежим теперь является опцией по умолчанию в тарифных планах Pro, Max и Team.

Совет 32: Управляйте Claude Code со своего телефона

Remote Control позволяет управлять Claude Code со своего телефона, что отлично сочетается с авторежимом — вы можете запустить задачу, отойти и проверять её из любого места. Есть пару способов использовать эту функцию.

Запустите /remote-control внутри существующей сессии, следуйте инструкциям, и вы сможете управлять той же сессией со своего телефона. Поскольку это одна и та же сессия, вы можете переключаться между телефоном и компьютером. Также можно использовать сокращённую команду /rc.

Или запустите сервер с помощью claude remote-control --spawn=worktree --capacity=N, что позволит вам начинать совершенно новые сессии со своего телефона, а не просто подключаться к уже открытой. Здесь --spawn=worktree выделяет каждой новой сессии собственный git worktree, чтобы они не мешали друг другу, а --capacity задаёт количество сессий, которые могут работать одновременно. Я сделал для этого алиас cr, поэтому команда выглядит просто как cr --spawn=worktree --capacity=N.

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

Одна вещь, за которой нужно следить: если опция «Enable Remote Control for all sessions» не установлена, она всё равно может включаться автоматически для каждой новой сессии. Явно установите её в значение false, если вы этого не хотите, либо через /config, либо добавив "remoteControlAtStartup": false в файл ~/.claude/settings.json.

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

Совет 33: Научитесь использовать артефакты

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

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

Это также отлично работает с телефона. В мобильном приложении Claude нажмите на карточку артефакта, и он откроется прямо в приложении.

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

Совет 34: Пишите много тестов (и используйте TDD)

По мере того как вы пишете больше кода с помощью Claude Code, становится легче допустить ошибку. Ревью PR и визуальные Git-клиенты помогают обнаруживать проблемы (как я упоминал ранее), но написание тестов крайне важно по мере роста вашей кодовой базы.

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

Я обнаружил, что TDD (Test-Driven Development, разработка через тестирование) отлично работает с Claude Code:

  1. Сначала напишите тесты
  2. Убедитесь, что они падают
  3. Закоммитьте тесты
  4. Напишите код, чтобы они проходили

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

Если вы хотите быть абсолютно уверены, просмотрите тесты сами, чтобы убедиться, что они не делают ничего глупого, например, просто возвращают true.

Совет 35: Будьте смелее в неизведанном; итеративное решение проблем

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

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

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

Далее последовал совместный итеративный процесс. Claude Code предлагал возможные первопричины и варианты решения. Я экспериментировал с ними. Некоторые оказались тупиковыми, и мы двигались в другом направлении. На протяжении всего этого я контролировал свой темп. Иногда я ускорялся, например, когда позволял ему исследовать разные пространства решений или участки кодовой базы. Иногда замедлялся, спрашивая: «что именно означает эта строка?» Контроль уровня абстракции, контроль скорости.

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

Совет 36: Запуск bash-команд и субагентов в фоновом режиме

Когда в Claude Code выполняется долгая bash-команда, вы можете нажать Ctrl+B, чтобы перевести её выполнение в фон. Claude Code умеет управлять фоновыми процессами — он может проверить их позже с помощью инструмента BashOutput.

Это полезно, когда вы понимаете, что команда выполняется дольше ожидаемого, и хотите, чтобы Claude тем временем занимался чем-то другим. Затем вы можете либо попросить его использовать метод экспоненциальной задержки (exponential backoff), который я описывал в Совете 15, чтобы проверять прогресс, либо просто дать ему заняться чем-то совершенно другим, пока процесс работает.

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

Стратегическое использование субагентов

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

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

Совет 37: Наступила эпоха персонализированного ПО

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

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

Вот ещё один пример: korotovsky/slack-mcp-server — популярный Slack MCP почти с 1 000 звёзд — задуман для запуска в виде Docker-контейнера. У меня возникли трудности с его плавным использованием внутри моего собственного Docker-контейнера (сложности Docker-in-Docker). Вместо того чтобы бороться с этой конфигурацией, я просто попросил Claude Code написать CLI напрямую с использованием Slack Node SDK. Всё отлично заработало.

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

Совет 38: Навигация и редактирование поля ввода

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

Навигация: - Ctrl+A — Перейти в начало строки - Ctrl+E — Перейти в конец строки - Option+Left/Right (Mac) или Alt+Left/Right — Перемещение назад/вперёд по словам

Редактирование: - Ctrl+W — Удалить предыдущее слово - Ctrl+U — Удалить от курсора до начала строки - Ctrl+K — Удалить от курсора до конца строки - Ctrl+C / Ctrl+L — Очистить текущий ввод - Ctrl+G — Открыть ваш запрос во внешнем редакторе (полезно для вставки длинного текста, так как прямая вставка в терминал может быть медленной)

Если вы знакомы с bash, zsh или другими оболочками, вы будете чувствовать себя как дома.

Для Ctrl+G редактор определяется вашей переменной окружения EDITOR. Вы можете задать её в конфигурации оболочки (~/.zshrc или ~/.bashrc):

export EDITOR=vim      # or nano, code, nvim, etc.

Или в ~/.claude/settings.json (требуется перезапуск):

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

Ввод переносов строк (многострочный ввод):

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

Вставка изображений: - Ctrl+V (Mac/Linux) или Alt+V (Windows) — Вставить изображение из буфера обмена

Примечание: На Mac это Ctrl+V, а не Cmd+V.

Отключение предложений запросов:

Если вы находите предложения запросов (предсказанное следующее сообщение, которое появляется в вашем поле ввода) раздражающими, вы можете отключить их. Запустите /config и выключите «Предложения запросов», или задайте это в ~/.claude/settings.json:

{
  "promptSuggestionEnabled": false
}

Совет 39: Уделите время планированию, но также быстро создавайте прототипы

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

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

Например, недавно я экспериментировал с созданием средства просмотра различий (diff viewer). Сначала я попробовал простой прототип на bash с использованием tmux и lazygit, затем попытался создать свой собственный просмотрщик git с помощью Ink и Node. У меня возникло много проблем с разными вещами, и в итоге я не опубликовал никакие из этих результатов. Но то, что напомнил мне этот проект, — это важность планирования и прототипирования. Я обнаружил, что, просто немного лучше спланировав в начале, прежде чем позволить ему писать код, вы сможете направлять его лучше. Вам всё ещё нужно направлять его в процессе написания кода, но предварительное небольшое планирование действительно очень полезно.

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

Совет 40: Упрощайте излишне сложный код

Я обнаружил, что Claude Code иногда усложняет вещи и пишет слишком много кода. Он вносит изменения, о которых вы не просили. Похоже, у него просто есть предубеждение в пользу написания большего количества кода. Код может работать правильно, если вы следовали другим советам в этом руководстве, но его будет трудно поддерживать и трудно проверять. Это может стать своего рода кошмаром, если вы недостаточно его проверите.

Поэтому иногда вы хотите проверить код и попросить его упростить вещи. Вы могли бы исправить всё сами, но вы также можете просто попросить его упростить. Вы можете задавать вопросы вроде «почему ты внёс это конкретное изменение?» или «почему ты добавил эту строку?» Некоторые говорят, что если писать код только через ИИ, вы никогда не сможете его понять. Но это верно лишь в том случае, если вы не задаёте достаточно вопросов. Если вы убедитесь, что понимаете каждую мелочь, вы на самом деле сможете разобраться в коде быстрее, чем обычно, потому что всегда можете спросить ИИ. Особенно когда работаете над большим проектом.

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

Совет 41: Автоматизация автоматизации

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

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

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

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

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

Совет 42: Делитесь знаниями и вносите вклад там, где можете

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

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

Так что обмен знаниями — это не только построение личного бренда или закрепление изученного. Это ещё и способ узнавать новое в этом процессе. Это не всегда дорога с односторонним движением.

Что касается вклада в проект, я отправлял issues в репозиторий Claude Code. Я рассуждал так: если они прислушаются — отлично. Если нет — тоже вполне нормально. У меня не было никаких ожиданий. Но в версии 2.0.67 я заметил, что они учли сразу несколько предложений из моих отчётов:

  • Исправлен сброс позиции прокрутки после удаления правила разрешений в /permissions
  • Добавлена функция поиска в команду /permissions

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

Совет 43: Продолжайте учиться!

Есть несколько эффективных способов продолжать изучать Claude Code:

Спросите самого Claude Code - Если у вас есть вопрос о Claude Code, просто задайте его. В Claude Code есть специализированный субагент для ответов на вопросы о его собственных функциях, слеш-командах, настройках, хуках, MCP-серверах и многом другом.

Смотрите примечания к релизам - Введите /release-notes, чтобы увидеть, что нового в вашей текущей версии. Это лучший способ узнать о новейших функциях.

Учитесь у сообщества - Сабреддит r/ClaudeAI — отличное место, чтобы учиться у других пользователей и посмотреть, какие рабочие процессы используют люди.

Совет 44: Установите плагин dx

Этот репозиторий также является плагином Claude Code под названием dx (developer experience — опыт разработчика). Он объединяет несколько инструментов из приведённых выше советов в единую установку:

Навык Описание
/dx:gha <url> Анализ сбоев GitHub Actions (Совет 27)
/dx:handoff Создание handoff-документов для непрерывности контекста (Совет 8)
/dx:half-clone Полуклонирование для сокращения контекста (Совет 21)
/dx:quarter-clone Четверть-клонирование для ещё большего сокращения контекста (Совет 21)
/dx:reddit-fetch Получение контента Reddit через JSON API Reddit
/dx:review-claudemd Анализ бесед для улучшения файлов CLAUDE.md (Совет 28)
/dx:hn-summarize Краткое изложение топовых новостей, статей и веток комментариев Hacker News
/dx:version-check Рекомендация, какую версию Claude Code использовать или стоит ли обновляться
/dx:private-github-search Полнотекстовый поиск по всем вашим репозиториям GitHub, включая приватные
Установка двумя командами: 
claude plugin marketplace add ykdojo/claude-code-tips
claude plugin install dx@ykdojo

После установки команды становятся доступны как /dx:half-clone, /dx:handoff и /dx:gha. Навык reddit-fetch вызывается автоматически, когда вы спрашиваете о URL-адресах Reddit. Навык review-claudemd анализирует ваши недавние беседы и предлагает улучшения для ваших файлов CLAUDE.md. Для команды half-clone см. рекомендуемые разрешения.

Рекомендуемый помощник: Playwright MCP для автоматизации браузера — добавьте с помощью claude mcp add -s user playwright npx @playwright/mcp@latest

Совет 45: Скрипт быстрой настройки

Если вы хотите настроить несколько рекомендаций из этого репозитория сразу, есть скрипт настройки, который выполняет многие из них:

bash <(curl -s https://raw.githubusercontent.com/ykdojo/claude-code-tips/main/scripts/setup.sh)

Скрипт показывает всё, что он настроит, и позволяет пропустить любые пункты:

INSTALLS:
  1. DX plugin - skills like /dx:gha, /dx:handoff, and reddit-fetch

SETTINGS (~/.claude/settings.json):
  2. Status line - shows model, git branch, uncommitted files, token usage at bottom of screen
  3. Disable auto-updates - prevents Claude Code from auto-updating
  4. Lazy-load MCP tools - only loads MCP tool definitions when needed, saves context
  5. Read(~/.claude) permission - allows the half-clone command to read conversation history
  6. Read(//tmp/**) permission - allows reading temporary files without prompts
  7. Disable attribution - removes Co-Authored-By from commits and attribution from PRs

SHELL CONFIG (~/.zshrc or ~/.bashrc):
  8. Aliases: c=claude, ch=claude --chrome, cs=claude --dangerously-skip-permissions
  9. Fork shortcut: --fs expands to --fork-session (e.g., claude -c --fs)

Skip any? [e.g., 1 4 7 or Enter for all]:

Совет 46: Переключение между несколькими аккаунтами Claude

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

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

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

claude setup-token   # log in as each account, copy the 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 для обновления.

Совет 47: Используйте GitHub как свою базу знаний

Я использую GitHub как свою базу знаний — своего рода замену Notion. Вместо того чтобы открывать документ Notion, я просто создаю новый репозиторий или нахожу существующий приватный репозиторий, куда могу поместить свои заметки. Я диктую свои мысли и развиваю свои заметки там, а если мне нужно провести исследование, я позволяю Claude Code выполнить его и обновить эти репозитории.

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

Одного не хватало — поиска: собственный поиск GitHub плохо работает для приватных репозиториев. Я написал об этой проблеме и о том, как я её решил, в Отсутствующий приватный поиск по GitHub — это навык, который зеркалирует все ваши репозитории локально и ищет их с помощью ripgrep, поэтому я могу просто спросить Claude Code «в каком репозитории находится X» — и он найдёт его.

См.: Почему GitHub — лучшая база знаний

Совет 48: Учитесь проверять код через документ TESTING.md

Когда вам нужно проверить большой объём кода (сгенерированный Claude Code, PR от коллеги или внешний PR), настоящая сложность заключается в создании ментальной модели происходящего. И вопрос в том, как вы узнаете, что это корректно? Вы можете читать код. Вы можете писать тесты. Но есть ещё один способ, который на уровень выше них.

Моя рекомендация — попросить Claude Code тщательно протестировать всё в данном коде, пусть он задокументирует, как он тестировал и проверял всё, в документе TESTING.md, а затем вручную проверьте этот документ. Вы можете обмениваться комментариями туда и обратно, чтобы получить удобный для вас формат проверки. Если он слишком длинный, попросите сделать его короче. Если слишком короткий — запросите больше информации. Если там есть жаргон, которого вы не понимаете, попросите объяснить или упростить. Вот реальный пример: TESTING.md из этого репозитория. Всё началось с проверки одного внешнего PR, где Claude Code воспроизвёл ошибку на реальном Windows-раннере в GitHub Actions, проверил исправление и обобщил всё, что было протестировано. Теперь это постоянно пополняемый журнал, который мы обновляем при каждой проверке. Отслеживание таким образом в git даёт вам запись о том, как всё было протестировано. Если кто-то спросит, как вы знаете, что что-то работает так, как задумано, вы можете просто отправить их к этому документу.

📺 Связанный доклад: Claude Code Masterclass — уроки и примеры проектов за 31 месяц агентного программирования

📝 История: Как я получил работу на полную ставку с помощью Claude Code

📰 Рассылка: Агентное программирование с дисциплиной и мастерством — выведите практику агентного программирования на новый уровень

Комментарии
Войдите, чтобы оставить комментарий