Рычаги Claude Code

Четыре вещи требуют вмешательства до того, как начнётся всё остальное.

Принцип на будущее: в settings.json — только имена переменных и пути к хелперам. Значения секретов живут в ~/.secrets/ с правами 600 и попадают в процесс только через окружение.

Три сломанных MCP-сервера

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

claude plugin disable telegram@claude-plugins-official
claude plugin disable terraform@claude-plugins-official
claude plugin disable expo@claude-plugins-official

Ещё два пункта

• skipDangerousModePermissionPrompt: true — снят последний барьер перед bypass-режимом. На машине с живыми сервисами и десятком проектов это осознанный риск, а не настройка по умолчанию.
• autoUpdates: false — ты сидишь на срезе версии. Раз в неделю: claude update плюс claude plugin update.

Без этой модели остальные модули — набор трюков. С ней — система.

Что уходит в модель на каждом Enter

┌─ СИСТЕМНЫЙ ПРОМПТ ────────────────────────────────┐
│ 1. Базовые инструкции Claude Code                 │
│ 2. Output style                                   │
│ 3. Описания всех активных инструментов            │ ← плагины дорожают здесь
│ 4. Список скиллов (name + description, не тело!)  │
│ 5. Список субагентов (description)                │
│ 6. Инструкции MCP-серверов                        │
│ 7. Динамика: cwd, git status, дата, окружение     │
├─ КОНТЕКСТ ────────────────────────────────────────┤
│ 8. CLAUDE.md (все уровни иерархии)                │
│ 9. MEMORY.md + подтянутые файлы памяти            │
├─ ДИАЛОГ ──────────────────────────────────────────┤
│ 10. Вся история: сообщения, КАЖДЫЙ вызов          │
│     инструмента и КАЖДЫЙ его результат            │ ← 90 % расхода здесь
└───────────────────────────────────────────────────┘

Три следствия, определяющие всё остальное:

1. Результаты инструментов — главный пожиратель контекста. Один Read большого файла стоит дороже, чем весь диалог за час. Отсюда субагенты: агент читает сорок файлов в своём контексте и возвращает десять строк.
2. Скиллы и субагенты дёшевы, пока не вызваны — в промпте висит только строчка описания. Поэтому тридцать скиллов — нормально, а тридцать MCP-серверов — дорого: их полные схемы инструментов присутствуют всегда.
3. Порядок слоёв стабилен, поэтому работает кэш промпта. Отсюда невозможность «подчистить середину» диалога — только сжать или обрубить.

Пять способов дать знание — и когда какой

Центральная таблица курса. Каждый раз, когда захочется «чтобы Claude всегда делал X», сверяйся с ней.

Ввод

Клавиши сверяй в /help — они меняются между версиями, и у тебя может быть свой keybindings.json: Shift+Tab — цикл режимов разрешений, Esc — прервать, Esc Esc — перемотка, Ctrl+R — развернуть вывод, Ctrl+L — очистить экран.

Плановый режим — самый недооценённый инструмент

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

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

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

У тебя fileCheckpointingEnabled: true, и каталог file-history это подтверждает. /rewind откатывает на выбор: только диалог, только файлы, или и то и другое.

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

Возобновление

claude -c                     # продолжить последнюю сессию в этом каталоге
claude -r "статусбар"         # выбор из списка с поиском по строке
claude -c --fork-session      # продолжить, но с НОВЫМ id — история ветвится
claude --from-pr 42           # возобновить сессию, привязанную к PR
claude -n "рефакторинг"       # имя сессии — видно в /resume и в заголовке терминала

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

Шесть режимов

Слои настроек

политика организации
      ↓
~/.claude/settings.json              модель, хуки, statusline, плагины
      ↓
<проект>/.claude/settings.json       общее для команды, коммитится
      ↓
<проект>/.claude/settings.local.json личное, в .gitignore
      ↓
флаги CLI                            --model, --permission-mode, --settings

Синтаксис правил

{
  "permissions": {
    "allow": [
      "Bash(git status)",              // ровно эта команда
      "Bash(git *)",                   // любая git-подкоманда
      "Read(//home/**)",               // glob; двойной слэш = абсолютный путь
      "WebFetch(domain:docs.claude.com)"
    ],
    "deny":  [ "Read(//home/admin/.secrets/**)" ],
    "ask":   [ "Bash(git push *)" ]    // переспрашивать даже в auto
  }
}

{
  "permissions": {
    "deny": [
      "Read(//home/admin/.secrets/**)",
      "Read(//home/admin/.ssh/**)",
      "Read(//home/admin/.git-credentials)",
      "Read(//home/**/.env)",
      "Read(//home/admin/.claude/.credentials.json)"
    ],
    "ask": [ "Bash(git push *)", "Bash(sudo systemctl *)" ]
  }
}

Для скриптов

claude --allowedTools "Read Grep Glob"     # ровно эти инструменты
claude --tools ""                          # вообще без инструментов — чистый чат
claude --add-dir /home/A /home/B           # доступ к каталогам вне cwd

--add-dir — прямое решение задачи «посмотреть на два проекта сразу», не переезжая в общий корень.

Ты работаешь с миллионным окном и авто-сжатием на отметке 600k. Это щедро, но не бесплатно: чем длиннее контекст, тем медленнее и дороже каждый ход — и тем выше шанс, что важная деталь утонет среди мусора от поисков.

Стратегия: /clear вместо /compact

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

• Задача сменилась → /clear. Не тащи хвост предыдущей темы.
• Задача та же, но длинная → /compact с указанием, что сохранить.
• Нужен переход с сохранением состояния → зафиксируй итог в файл, затем /clear, затем прочитай файл заново.

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

Экономия на входе

• Не проси Read там, где хватит субагента.
• Указывай точный путь: @docs/PLAN.md дешевле, чем «посмотри в документации».
• Держи CLAUDE.md коротким — он в контексте всегда и у всех сессий.
• claude plugin details <name> показывает прогноз стоимости плагина в токенах. Смотри до установки.

Иерархия и импорты

Читаются и склеиваются все уровни: домашний, проектный, подкаталожный, глобальный ~/.claude/CLAUDE.md (у тебя его нет). /init генерирует стартовый файл, /memory редактирует текущие.

# CLAUDE.md
Общие правила тут.

Архитектура: @docs/ARCHITECTURE.md
Соглашения:  @docs/CONVENTIONS.md

Импорт держит CLAUDE.md картой, а не свалкой. Оборотная сторона — импорт грузится всегда. Если знание нужно редко, это скилл, а не импорт.

Что писать, а что нет

Память

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

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

Самый дешёвый прирост в курсе. Файл .md в ~/.claude/commands/: имя файла — имя команды, содержимое — промпт.

---
description: Проверить здоровье всех живых сервисов машины
argument-hint: [имя-сервиса]
allowed-tools: Bash(systemctl status *), Bash(journalctl *), Read
model: sonnet
---

Проверь состояние сервисов на этой машине: $ARGUMENTS
(если аргумент пуст — проверь все)

Для каждого выведи одной строкой: имя, active/inactive, uptime,
последние ошибки за 24 часа. В конце — таблица и один вывод:
всё ли в порядке.

Последнее даёт команды, которые сами собирают контекст:

Диск:     !`df -h / | tail -1`
Память:   !`free -h | grep Mem`
Сервисы:  !`systemctl is-active mtg claude-agent 2>&1`

Проанализируй и скажи: что требует внимания сегодня?

Подкаталоги дают неймспейсы: commands/ops/health.md → /ops:health.

Первые пять команд под твой профиль

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

~/.claude/skills/qb-veha/
├── SKILL.md              ← обязательный
├── references/format.md  ← подгружается по необходимости
└── scripts/extract.py    ← я могу запустить

---
name: qb-veha
description: Работа с вехами проекта — определить текущую веху, свериться
  с планом, оформить переход к следующей. Использовать при любой задаче,
  где упоминаются вехи, этапы, ROADMAP или переход между стадиями.
---

# Работа с вехами

## Шаг 1. Определить состояние
Прочитай docs/PLAN.md и docs/STATE.md. Веха считается текущей, если …

## Шаг 3. Оформление
Формат описан в references/format.md — прочитай его,
когда дойдёшь до оформления.

Прогрессивное раскрытие — главная техника: SKILL.md короткий, как карта; детали в references/, которые читаются по необходимости. Скилл может быть огромным по знанию и почти бесплатным по контексту.

claude plugin init <name>        # скаффолд в ~/.claude/skills/<name>/
claude plugin validate <path>    # проверить корректность
claude plugin details <name>     # инвентарь + прогноз токенов
claude plugin eval <target>      # прогнать eval-кейсы и оценить качество

claude plugin eval — это уже инженерия скиллов: пишешь тест-кейсы, прогоняешь, получаешь оценку с базовой линией «без плагина». Так проверяют, что скилл действительно срабатывает на нужных формулировках. У тебя стоит плагин skill-creator — начни с него.

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

Без субагента:                      С субагентом:
я читаю 40 файлов                   агент читает 40 файлов (свой контекст)
→ 200k токенов в моём контексте     → мне возвращается 500 токенов
→ остаток диалога тормозит          → мой контекст чист

Второе и недооценённое: субагенты работают параллельно. Три агента на три подсистемы — это три контекста одновременно.

Встроенные — доступны прямо сейчас

Свой субагент

---
name: ops-auditor
description: Аудит состояния сервера — systemd-сервисы, диск, память, swap,
  логи с ошибками, зависшие процессы. Использовать, когда нужно понять,
  что не так с машиной, или сделать регулярную проверку здоровья.
tools: Bash, Read, Grep, Glob
model: sonnet
---

Ты — аудитор состояния Linux-сервера. Работаешь read-only:
никогда ничего не чинишь и не перезапускаешь, только диагностируешь.

Порядок: systemctl --failed → df -h, free -h → journalctl -p err
за 24 часа, сгруппировать по источнику → топ процессов.

Верни СТРОГО такой отчёт:
## Критично
## Требует внимания
## Норма
Каждый пункт — одна строка: симптом → причина → команда для проверки.
Без воды и предисловий.

Пять приёмов

1. Read-only по умолчанию. Агент без Edit/Write — агент, которого можно запускать не глядя.
2. Жёсткий формат вывода. Возврат агента попадает в мой контекст. «Верни СТРОГО такой отчёт» — не грубость, а экономия.
3. Модель под задачу. Механический поиск — sonnet или haiku. Архитектура — opus. Разница в цене кратная.
4. Параллельный запуск. Несколько независимых агентов стартуют одним ходом.
5. Изоляция в worktree — несколько агентов правят файлы, не конфликтуя.

Первые три агента

Хук получает JSON на stdin и отвечает кодом возврата: 0 — разрешить, 2 — заблокировать (stderr уходит мне как обратная связь). Точный список событий и формат ответа сверь через /hooks.

Страж секретов — гарантия вместо надежды

#!/usr/bin/env python3
import json, sys, re

FORBIDDEN = re.compile(r'\.secrets/|\.ssh/|\.git-credentials|\.env$|credentials\.json')

data = json.load(sys.stdin)
inp = data.get("tool_input", {})
target = f'{inp.get("file_path","")} {inp.get("command","")} {inp.get("pattern","")}'

if FORBIDDEN.search(target):
    print("Отказано: путь относится к секретам (правило CLAUDE.md).", file=sys.stderr)
    sys.exit(2)
sys.exit(0)

"PreToolUse": [
  { "matcher": "Read|Edit|Write|Bash|Grep",
    "hooks": [{ "type": "command",
                "command": "python3 ~/.claude/hooks/guard_secrets.py" }] }
]

Ещё два, которые тебе стоит завести: автоформат на PostToolUse для Edit|Write — убирает целый класс мелких итераций; и инжектор контекста на SessionStart, подмешивающий свежее состояние (текущая веха, статус сервисов, незакоммиченные изменения).

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

claude plugin list                 # что установлено
claude plugin details <name>       # состав + ПРОГНОЗ ТОКЕНОВ
claude plugin enable/disable <name>
claude plugin prune                # убрать осиротевшие зависимости
claude mcp                         # управление MCP

Аудит: пользовался ли я этим за месяц?

• expo — мобильная разработка. Есть такие проекты? Плюс он не авторизован.
• figma — дизайн. Используешь?
• qdrant-skills, redis-development — только если реально работаешь с этими БД.
• terraform — сломан и по профилю инфраструктуры не нужен.
• chrome-devtools-mcp + playwright — два браузерных стека сразу. Оставь один.

serena (семантический поиск по коду через LSP) и context7 (свежая документация библиотек) — самые полезные для разработки, их держи.

Проектный .mcp.json

{
  "mcpServers": {
    "qb-db": {
      "command": "python3",
      "args": ["/home/Qb/tools/mcp_db.py"],
      "env": { "DB_URL": "${DB_URL}" }
    }
  }
}

Для CI обязательно: --mcp-config ./ci.mcp.json --strict-mcp-config. Второй флаг игнорирует все прочие конфигурации MCP — без него окружение непредсказуемо.

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

Git worktrees

claude -w                       # новый worktree для этой сессии
claude -w feature-auth --tmux   # + сразу tmux-сессия

Worktree — отдельный рабочий каталог на той же git-истории. Две сессии в двух worktree правят разные каталоги: конфликтов нет, ветки независимы. Сейчас твои окна смотрят в одни и те же файлы — claude -w … --tmux даёт то же самое, но с изоляцией.

Фоновые агенты

claude --bg -p "прогони тесты и собери отчёт по падениям"
claude agents                   # интерактивный менеджер
claude agents --json            # список активных сессий в JSON
claude agents --json --all      # включая завершённые
claude agents --cwd /home/Qb    # только из этого каталога

Облако и расписание

claude --cloud "описание задачи"   # облачная сессия — VDS не нагружается
claude --remote-control [имя]      # удалённое управление сессией
claude --teleport [session]        # телепорт в сессию

Для долгих прогонов при ограниченной памяти сервера облачные сессии — рабочий обход. Плюс /schedule для облачных агентов по cron и /loop для повторяющихся промптов.

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

claude -p "..." --output-format json           # один JSON с результатом и метаданными
claude -p "..." --output-format stream-json    # поток событий в реальном времени
claude -p "..." --include-partial-messages     # + частичные чанки
claude -p "..." --include-hook-events          # + события хуков

Структурированный вывод — ключ к пайплайнам

claude -p "разбери этот лог и верни структуру" \
  --json-schema '{
    "type":"object",
    "properties":{
      "errors":{"type":"array","items":{"type":"string"}},
      "severity":{"type":"string","enum":["low","medium","high"]}
    },
    "required":["errors","severity"]
  }'

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

Бюджет, агенты и изоляция

claude -p "..." --max-budget-usd 2.00     # жёсткий потолок трат
claude -p "..." --fallback-model sonnet   # запасная модель при перегрузе

claude --agents '{"auditor":{"description":"Аудит сервисов",
                  "prompt":"Ты аудитор Linux. Только диагностика."}}' -p "проверь сервис"

claude --bare -p "..." --add-dir /home/Qb # без хуков, LSP, плагинов, авто-памяти

Двусторонний поток (--input-format stream-json --output-format stream-json --replay-user-messages) — транспорт для интерактивных обёрток: твой процесс шлёт сообщения в stdin и читает события из stdout. Долгоживущий токен для автоматики под подпиской — claude setup-token, и класть его в ~/.secrets/, не в конфиг.

Ты ездишь на максимальной передаче постоянно: opus[1m] плюс xhigh. Для архитектуры и сложной отладки это правильно. Для «переименуй переменную в трёх файлах» — расточительно и медленно.

Управление: /model, /effort, /fast (Opus с ускоренным выводом, не даунгрейд модели), /usage для расхода и лимитов.

Про лимиты Max цифр по памяти не привожу — они меняются. Источник истины: /usage и официальная документация. Механика, которую стоит знать: лимит считается по скользящему окну, и opus на xhigh расходует его в разы быстрее sonnet на medium. Если упираешься в потолок к середине дня — проблема не в подписке, а в том, что вся рутина едет на максимальной передаче.

/code-review              # ревью текущего диффа
/code-review high         # тщательность: low | medium | high | max
/code-review 42           # ревью PR №42
/code-review --fix        # применить найденное к рабочему дереву
/code-review --comment    # инлайн-комментарии в PR

Уровни low/medium дают мало находок, но высокой уверенности; high/max — шире охват и допускают неточные.

Ultrareview (claude ultrareview или /code-review ultra) — многоагентное облачное ревью ветки. Тяжёлое и платное, запускается только тобой: я не могу его инициировать. Нужен git-репозиторий; безаргументная форма работает с локальной веткой и не требует GitHub-remote.

Рядом: /security-review — ревью изменений на безопасность, /simplify — чистка на упрощение (баги не ищет).

Процесс качества

1. plan mode           → согласовали подход
2. работа              → acceptEdits
3. /code-review high   → нашли проблемы
4. /simplify           → почистили
5. коммит              → ветка, не main
6. /code-review ultra  → перед мержем важного

claude doctor                  # проверка установки
claude --safe-mode             # ВСЕ кастомизации выключены
claude --bare                  # минимальный режим
claude -d "api,hooks"          # debug по категориям
claude -d "!1p,!file"          # debug с исключениями
claude --debug-file /tmp/cc.log

Что не чистить руками — это состояние клиента, а не мусор: sessions, session-env, file-history, tasks, shell-snapshots, транскрипты проектов. У тебя это уже записано в CLAUDE.md — правильно.

Карта файлов

~/.claude/
├── settings.json           модель, хуки, statusline, плагины (БЕЗ СЕКРЕТОВ)
├── settings.local.json     личные разрешения, outputStyle
├── CLAUDE.md               глобальные инструкции          ← нет
├── keybindings.json        свои клавиши                   ← нет
├── commands/               слэш-команды                   ← СОЗДАТЬ
├── skills/                 скиллы                         ← СОЗДАТЬ
├── agents/                 субагенты                      ← СОЗДАТЬ
├── hooks/                  скрипты хуков                  ← СОЗДАТЬ
├── workflows/              workflow-скрипты               ← СОЗДАТЬ
└── projects/<slug>/memory/ авто-память

<проект>/
├── CLAUDE.md               инструкции проекта
├── .mcp.json               MCP-серверы проекта
└── .claude/
    ├── settings.json       общее для команды (коммитится)
    ├── settings.local.json личное (в .gitignore)
    └── commands/ skills/ agents/

Флаги

# сессия
-c  -r  --fork-session  -n "имя"  --from-pr N

# доступ
--permission-mode plan|acceptEdits|auto|dontAsk|manual|bypassPermissions
--add-dir DIR   --allowedTools   --disallowedTools   --tools

# модель
--model opus|sonnet|fable   --effort low..max   --fallback-model

# параллельность
-w [имя]   --tmux   --bg   --cloud   --remote-control   --teleport

# headless
-p   --output-format json|stream-json   --json-schema   --max-budget-usd
--agents JSON   --mcp-config   --strict-mcp-config   --bare

# диагностика
--safe-mode   -d [фильтр]   --debug-file   --verbose

Подкоманды

claude agents    claude mcp       claude plugin      claude doctor
claude update    claude auth      claude setup-token claude ultrareview
claude import    claude project   claude auto-mode   claude install

1. Новая нетривиальная задача начинается с планового режима.
2. Задача сменилась — /clear, а не /compact.
3. Итог длинной сессии — в файл, затем /clear, затем прочитать файл.
4. /context раз в неделю, как техосмотр.
5. Секреты — только в ~/.secrets/ и только через окружение.
6. Гарантия — это deny-правило или хук, а не строчка в CLAUDE.md.
7. Много читать → субагент. Мой контекст — для решений, не для сырых данных.
8. Субагент по умолчанию read-only.
9. Субагенту — жёсткий формат ответа.
10. Рутина на sonnet, архитектура на opus.
11. model: во фронтматтере агентов и команд — бесплатная экономия.
12. Повторил промпт трижды — заведи слэш-команду.
13. Объяснил процедуру дважды — заведи скилл.
14. description скилла пишется от «когда применять».
15. Тело скилла в references/, SKILL.md — карта.
16. Параллельные ветки работы — в разных worktree.
17. В CI: --bare --strict-mcp-config --max-budget-usd.
18. --json-schema вместо парсинга прозы.
19. Странное поведение — --safe-mode первым делом.
20. Устаревший CLAUDE.md не нейтрален, он вредит. Обновляй.