TeoreticQuiz

AI

Материал для подготовки к собеседованию (Middle / Senior). Практический AI для разработчика: как работают LLM, промпт-инжиниринг, RAG, агенты, MCP, безопасность — и отдельно работа с Claude Code / Cowork (режимы, CLAUDE.md, MCP, skills, subagents). Термины на английском там, где это принято.

Содержание


Как работают LLM

LLM (Large Language Model) — большая языковая модель, обученная предсказывать следующий токен по предыдущим. По сути это очень мощный «автодополнитель»: на вход — текст (промпт), на выход — наиболее вероятное продолжение, токен за токеном (авторегрессия).

Ключевое (для понимания на собеседовании):

  • В основе — архитектура Transformer с механизмом attention (внимания): модель взвешивает, какие части входа важны для предсказания следующего токена.
  • Модель не «знает» фактов в базе данных — она хранит статистические закономерности из обучающих данных в весах. Отсюда галлюцинации и knowledge cutoff (обучена на данных до определённой даты, о свежем не знает).
  • Модель stateless — не помнит прошлые запросы сама по себе; «память» диалога — это просто передача всей истории в контексте каждый раз.

Токены и контекстное окно

Токен — единица текста для модели (не буква и не слово, а кусочек: часто ~4 символа для английского, ~0.75 слова). «привет» может быть 1–2 токена, длинное слово — несколько. Стоимость API и лимиты считаются в токенах.

Контекстное окно (context window) — максимальное число токенов, которое модель может обработать за раз (вход + выход). Например, 200k токенов. В него входит всё: системный промпт, история диалога, приложенные документы, ответ. Когда контекст переполняется — старое приходится обрезать/суммировать.

Практические следствия: длинные документы бьют на части (чанки); историю диалога иногда суммируют; за контекстом следят, чтобы не «вытолкнуть» важное; чем больше контекст — тем дороже и (иногда) медленнее запрос, а модель может хуже «замечать» информацию в середине (проблема lost in the middle).


Параметры генерации

  • temperature — «случайность» вывода. 0 — детерминированно, всегда самый вероятный токен (для фактов, кода, извлечения данных); выше (0.7–1.0) — разнообразнее и «креативнее» (для текстов, брейншторма).
  • top-p (nucleus sampling) — выбирать из наименьшего набора токенов, чья суммарная вероятность ≥ p (например, 0.9). Альтернатива/дополнение к temperature.
  • top-k — выбирать из k самых вероятных токенов.
  • max_tokens — ограничение длины ответа.
  • stop sequences — строки, при которых генерация останавливается.
  • frequency/presence penalty — штрафы за повторения (у некоторых API).

Правило: для точных/повторяемых задач — низкая temperature; для творческих — выше.


Галлюцинации и ограничения

Галлюцинация — модель уверенно выдаёт правдоподобную, но неверную информацию (выдуманные факты, API, цитаты, ссылки). Причина — модель генерирует вероятное продолжение, а не проверяет истинность.

Как снижают: RAG (давать модели реальные источники в контексте), низкая temperature, требование цитировать источники, прямое разрешение отвечать «не знаю», проверка вывода (валидация, второй проход, evals), structured output. Полностью исключить нельзя — критичные ответы проверяют.

Другие ограничения: knowledge cutoff (не знает свежего), нет доступа к реальному времени/интернету без инструментов, ограниченная математика/подсчёты (лучше давать инструмент-калькулятор/код), чувствительность к формулировке промпта, предвзятости из обучающих данных.


Эмбеддинги и векторы

Эмбеддинг (embedding) — представление текста (или изображения) в виде вектора — массива чисел (например, 768 или 1536 измерений). Ключевое свойство: близкие по смыслу тексты дают близкие векторы (по косинусному расстоянию). Модель эмбеддингов отличается от генеративной LLM (её задача — не генерировать, а кодировать смысл).

Зачем: семантический поиск (найти по смыслу, а не по словам), кластеризация, классификация, рекомендации и — главное — RAG (поиск релевантных фрагментов знаний).

Хранят и ищут векторы в векторных БД / индексах: pgvector (PostgreSQL), Qdrant, Pinecone, Weaviate, Milvus, а также Elasticsearch/OpenSearch (kNN). Поиск ближайших — задача kNN (обычно приближённый ANN: HNSW).


Промпт-инжиниринг

Промпт-инжиниринг — искусство формулировать запрос так, чтобы получить нужный результат.

Приёмы:

  • Zero-shot — просто задача без примеров.
  • Few-shot — дать 1–5 примеров «вход → выход» (модель схватывает формат/логику).
  • Chain-of-thought (CoT) — попросить «рассуждать пошагово» — повышает качество на логике/математике.
  • Роли в сообщениях: system (правила поведения, контекст, тон), user (запрос), assistant (ответы модели, в т.ч. прошлые). System-промпт задаёт «характер» и ограничения.
  • Structured output — просить строгий формат (JSON по схеме) для программной обработки; многие API умеют гарантировать JSON.

Хорошие практики: быть конкретным и однозначным; давать контекст и примеры; разбивать сложные задачи на шаги; использовать разделители/теги (например, XML-теги) для структуры; давать модели «выход» («если не знаешь — скажи»); итеративно улучшать промпт по результатам.

System: Ты — ассистент по коду. Отвечай кратко, только валидным JSON.
User: Извлеки из текста имя и возраст: "Вася, 30 лет"
Assistant: {"name": "Вася", "age": 30}

RAG (Retrieval-Augmented Generation)

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

Пайплайн:

  1. Индексация (offline): документы бьют на чанки → каждый чанк превращают в эмбеддинг → сохраняют в векторную БД.
  2. Запрос (online): вопрос пользователя → эмбеддинг вопроса → семантический поиск ближайших чанков в векторной БД → найденные фрагменты вставляют в промпт как контекст → LLM отвечает на основе них (и цитирует).
Вопрос → embedding → поиск в vector DB → топ-k релевантных чанков
       → промпт: "Ответь по контексту: {чанки}. Вопрос: {вопрос}"
       → LLM → ответ со ссылками на источники

Важные детали:

  • Чанкинг — как бить документы (по размеру, по смысловым блокам, с перекрытием overlap). Плохой чанкинг → плохой поиск.
  • Reranking — после векторного поиска переранжировать кандидатов более точной моделью (cross-encoder) для качества.
  • Гибридный поиск — комбинировать векторный (смысл) и лексический BM25 (точные термины).
  • Метаданные и фильтры — искать в рамках нужного документа/раздела/прав доступа.
  • Качество RAG зависит от качества поиска (retrieval), а не только от LLM.

RAG vs дообучение: RAG даёт актуальные и проверяемые знания без переобучения модели; проще обновлять (просто меняешь данные в индексе).


Function calling / tools

Function calling (tool use) — модель может не только отвечать текстом, но и «вызывать инструменты»: возвращать структурированный запрос на выполнение функции (с аргументами), которую выполняет ваш код, а результат возвращается модели.

Как это работает:

  1. Вы описываете модели доступные инструменты (имя, описание, JSON-схема параметров).
  2. Модель, поняв, что нужен инструмент, возвращает «tool call» с аргументами (например, get_weather(city="Москва")).
  3. Ваш код выполняет функцию (запрос к API/БД) и возвращает результат модели.
  4. Модель использует результат, чтобы сформировать финальный ответ.

Это даёт LLM «руки»: доступ к актуальным данным, БД, API, вычислениям, действиям. Основа агентов и RAG. Модель сама не выполняет код — она только просит его вызвать; выполнение и безопасность — на стороне приложения.


Агенты

Агент — LLM, которая в цикле сама решает, какие инструменты вызвать, чтобы достичь цели, наблюдает результаты и корректирует план (в отличие от одиночного «вопрос-ответ»).

Цикл агента (упрощённо): think (спланировать) → act (вызвать инструмент) → observe (получить результат) → повторить, пока задача не решена.

  • Агенту дают набор инструментов (поиск, чтение/запись файлов, выполнение кода, вызовы API) и цель.
  • Multi-agent — несколько специализированных агентов (оркестратор + исполнители), каждый со своей ролью/контекстом.
  • Риски: зацикливание, накопление ошибок, стоимость (много вызовов LLM), безопасность действий. Нужны лимиты шагов, проверки, подтверждения на опасные действия.

Фреймворки/подходы: LangChain, LlamaIndex, LangGraph (обзор); стандарт подключения инструментов — MCP (см. ниже). Claude Code и Cowork — примеры агентных систем.


MCP (Model Context Protocol)

MCP — открытый протокол (от Anthropic) для стандартизированного подключения LLM-приложений к внешним источникам данных и инструментам. Идея: «USB-C для AI» — единый способ дать модели доступ к БД, API, файлам, сервисам, вместо кастомной интеграции под каждый.

Модель клиент-сервер:

  • MCP-сервер — предоставляет возможности: tools (действия/функции), resources (данные/файлы для чтения), prompts (шаблоны). Например, MCP-сервер для GitHub, Slack, Postgres, файловой системы.
  • MCP-клиент — LLM-приложение (Claude Desktop, Claude Code, IDE), которое подключается к серверам и даёт модели их использовать.
  • Транспорт — stdio (локально) или HTTP/SSE (удалённо).

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


Fine-tuning vs RAG vs prompting

Три способа «адаптировать» модель под задачу:

Подход Что делает Когда
Prompting инструкции/примеры в промпте быстрее всего, дёшево; для большинства задач достаточно
RAG подмешивать актуальные данные из поиска нужны свежие/приватные/большие знания, проверяемость, частые обновления
Fine-tuning дообучить веса на своих данных нужен стабильный стиль/формат/поведение, узкая доменная задача, экономия токенов на больших объёмах

Практическое правило: сначала промптинг → потом RAG → и только при необходимости fine-tuning (он дорог, требует данных, не добавляет знаний в реальном времени). RAG и fine-tuning не взаимоисключающи (fine-tune для поведения + RAG для знаний).


Безопасность LLM-приложений

  • Prompt injection — атака, когда вредоносные инструкции подсовываются в ввод/данные, чтобы «переубедить» модель игнорировать системный промпт («забудь инструкции и сделай X»). Особенно опасен indirect prompt injection — инструкции спрятаны в данных, которые модель читает (веб-страница, документ, письмо).
  • Защита: не давать модели лишних прав (least privilege), подтверждение опасных действий человеком (human-in-the-loop), разделять доверенные инструкции и недоверенные данные, валидировать/санитизировать вход и выход, ограничивать инструменты, изоляция (sandbox) при выполнении кода.
  • Утечка данных — не отправлять в модель лишние приватные данные; учитывать политику провайдера по обучению на данных; PII-фильтрация.
  • Jailbreak — обход ограничений модели хитрыми промптами.
  • Не доверять выводу LLM слепо: он может содержать инъекции для нижестоящих систем (например, сгенерированный SQL/HTML) — экранировать/проверять.
  • Стоимость/DoS — лимиты токенов и частоты запросов.

Оценка качества (evals)

Evals — систематическая оценка качества LLM-приложения (нельзя «на глаз»). Подходы:

  • Golden dataset — набор «вход → ожидаемый выход», прогоняют и сравнивают.
  • Метрики: точность/полнота для извлечения, для RAG — качество retrieval (нашли ли нужные чанки) и faithfulness (ответ подтверждён источниками, нет галлюцинаций).
  • LLM-as-a-judge — использовать модель для оценки ответов по критериям (с осторожностью).
  • Регрессионные тесты промптов — при изменении промпта/модели прогонять evals, чтобы не сломать.
  • Мониторинг в проде — логировать запросы/ответы, собирать фидбек, ловить деградацию.

Интеграция в приложение

  • Работа с API (OpenAI, Anthropic и др.): системный/пользовательские сообщения, параметры, tool use.
  • Streaming — стримить ответ токенами (SSE), чтобы пользователь видел текст сразу (UX).
  • Управление стоимостью — считать токены, ограничивать контекст, кэшировать; prompt caching — переиспользовать неизменную часть промпта (система/документы) со скидкой и ускорением.
  • Rate limits и ретраи — обрабатывать 429, экспоненциальный backoff.
  • Structured output — просить JSON по схеме для надёжного парсинга.
  • Latency — крупные модели медленнее; для простых задач брать модель поменьше/побыстрее (маршрутизация задач по моделям).
  • Безопасность ключей — API-ключи в переменных окружения/секретах, не на клиенте.

Claude Code: что это, установка, модели

Claude Code — агентный инструмент от Anthropic для разработки: LLM-агент на моделях Claude, которому даны инструменты для реальной работы в проекте — чтение/запись/точечное редактирование файлов (Read/Write/Edit), выполнение команд в терминале (Bash), поиск по коду (Glob/Grep), веб (WebSearch/WebFetch), вопросы пользователю. Claude сам планирует и выполняет задачи: пишет код, чинит баги, рефакторит, запускает тесты, работает с git.

Где работает:

  • Терминал — интерактивный CLI (команда claude).
  • IDE — расширение для VS Code (табы, диффы, чекпоинты) и плагин для JetBrains (IntelliJ, PhpStorm, WebStorm, PyCharm, GoLand и др.).
  • Desktop-приложение (в т.ч. параллельные сессии) и веб-интерфейс на claude.ai для подписчиков.

Установка:

# Нативный установщик (macOS, Linux, WSL) — рекомендуемый
curl -fsSL https://claude.ai/install.sh | bash

# Homebrew
brew install --cask claude-code

# npm (устаревает; нужен Node.js 22+)
npm install -g @anthropic-ai/claude-code

Требуется аккаунт Pro/Max/Team/Enterprise или доступ через Console (API).

Модели Claude (общая логика выбора — «интеллект против скорости/цены»):

  • Opus — самые сложные, многошаговые задачи и комплексный код (макс. интеллект, дороже).
  • Sonnet — баланс интеллекта, скорости и цены (рабочая лошадка).
  • Haiku — быстрая и дешёвая, для высокочастотных/простых задач и низкой задержки.

Переключить модель в сессии — /model; модель можно задавать и для отдельных subagents/skills.


Claude Code, Cowork и Agent SDK

Три «лица» одного агентного движка Anthropic:

  • Claude Code — для разработчиков: терминал/IDE, работа с кодовой базой (git, тесты, рефакторинг). Максимум контроля.
  • Cowork — desktop-приложение для не-разработчиков: тот же движок, но для автоматизации файлов и рабочих задач (документы, папки, отчёты, презентации, таблицы). Ориентирован на обычную работу, а не на код.
  • Claude Agent SDK — библиотека (TypeScript и Python) для встраивания агента Claude в свои приложения/бэкенды. Тот же «движок» (инструменты, циклы, MCP, subagents, hooks, permissions), но программный интерфейс, а не UI. Ты сам хостишь, масштабируешь и изолируешь (нужны свои API/auth/sandbox). Ранее назывался Claude Code SDK.
// Claude Agent SDK (TypeScript) — упрощённо
import { query } from "@anthropic-ai/claude-agent-sdk";

for await (const message of query({ prompt: "Проанализируй репозиторий" })) {
  console.log(message);   // поток сообщений/действий агента
}
Claude Code Agent SDK
Интерфейс интерактивный CLI/IDE/Desktop программный (query()), поток сообщений
Где работает машина пользователя твоя инфраструктура (self-hosted)
Multi-user из коробки (desktop) строишь сам (API/auth/sandbox)
Общее инструменты, MCP, subagents, hooks, permissions то же самое

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


Режимы работы и разрешения

Система разрешений (permissions) — Claude Code по умолчанию спрашивает подтверждение перед потенциально опасными действиями (запись файла, выполнение команды). Это ключевая тема на собеседовании: как балансируют скорость и контроль.

Режимы (переключаются на лету — в терминале обычно Shift+Tab, в IDE/Desktop кнопкой/списком):

  • Default (обычный) — спрашивает перед каждой записью файла или командой.
  • Auto-accept edits — автоматически одобряет правки файлов и файловые операции в рабочей директории; остальное (например, произвольные команды) всё равно спрашивает.
  • Plan mode (планирование) — только чтение и рассуждения: Claude ничего не меняет, а исследует код и формирует план, который вы одобряете перед выполнением. Полезно для сложных задач — согласовать подход до правок.
  • Bypass permissions (--dangerously-skip-permissions) — отключает проверки; используют только в изолированном окружении (контейнер/VM/sandbox). Обычно защищённые пути (.git, .claude) всё равно оберегаются.

Тонкая настройка правил — в settings.json, приоритет deny > ask > allow (первое совпавшее правило в этом порядке; если ни одно не совпало — действует defaultMode):

{
  "permissions": {
    "defaultMode": "default",
    "allow": ["Bash(npm run test)", "Write(src/**)"],
    "deny":  ["Bash(rm -rf *)", "Write(.git/**)"],
    "ask":   ["WebSearch"]
  }
}

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


Настройки и структура .claude

Конфигурация проекта живёт в каталоге .claude/ и в файлах настроек. Уровни настроек (от команды к личным, с переопределением):

  • .claude/settings.json — командные настройки проекта (коммитятся в git): разрешения, переменные окружения, хуки, модель по умолчанию.
  • .claude/settings.local.json — личные переопределения (не в git): персональные права, секреты.
  • ~/.claude/settings.json — пользовательские настройки на все проекты.

Типичная структура каталога проекта:

.claude/
├── CLAUDE.md            # инструкции проекта (или ./CLAUDE.md в корне)
├── settings.json        # командные права/конфиг
├── settings.local.json  # личные переопределения (не в git)
├── skills/              # навыки проекта
│   └── my-skill/SKILL.md
├── agents/              # субагенты проекта
│   └── reviewer.md
└── commands/            # кастомные slash-команды
    └── deploy.md
.mcp.json                # MCP-серверы проекта (в корне)

В settings.json можно задать env (переменные для инструментов), hooks, permissions, model, период очистки истории и т.д.


CLAUDE.md и память

CLAUDE.md — файл инструкций/памяти проекта, который Claude Code автоматически подхватывает в начало каждой сессии. Это «постоянный контекст»: правила, соглашения, команды, архитектура — чтобы не повторять их каждый раз.

Что кладут в CLAUDE.md: правила и соглашения (стиль кода, паттерны, «как здесь принято»); частые команды (сборка, тесты, линт, запуск); структуру проекта и важные детали; ограничения (чего НЕ делать).

Иерархия/уровни (от узкого к широкому, узкое переопределяет широкое):

  1. ./CLAUDE.local.md — локальные личные правила для проекта (не коммитится).
  2. ./CLAUDE.md или ./.claude/CLAUDE.md — командные инструкции проекта (в git — общие для всех).
  3. ~/.claude/CLAUDE.md — личные правила на все проекты.
  4. Enterprise-политика организации (задаёт админ).

Полезное:

  • /init — просканировать проект и сгенерировать черновик CLAUDE.md (структура, команды сборки, стек), который дальше дополняют вручную.
  • Импорты — подключить другой файл в CLAUDE.md через @path (например, @~/.claude/CLAUDE.md или @docs/conventions.md).
  • Авто-память (auto memory) — заметки, которые Claude ведёт сам (предпочтения, контекст проекта, фидбек); загружается вместе с CLAUDE.md. Команда /memory открывает файлы памяти в редакторе.

Это ровно то, что сделано в этом проекте: корневой CLAUDE.md с правилами (одна тема — один файл, не вставлять картинки, писать по-русски и т.д.) — они соблюдаются во всех сессиях без повторения.


MCP в Claude Code

Claude Code — MCP-клиент: к нему подключают MCP-серверы, дающие доступ к внешним системам (GitHub, Slack, Jira/Atlassian, Notion, базы данных, файловые системы, браузер и т.д.). После подключения Claude использует их инструменты прямо в работе (создать issue, прочитать таблицу, сходить в БД).

Добавление сервера:

claude mcp add <имя> --transport stdio|http    # интерактивно

Транспорты: stdio (локальный процесс — быстро, но только локально), http (текущий стандарт для удалённых, в т.ч. облачных), sse (устаревает в пользу http).

Scopes (где хранится конфиг):

  • local — только вы и только в текущем проекте (по умолчанию; хранится в ~/.claude.json под путём проекта).
  • project — файл .mcp.json в корне репозитория (общий для команды, в git).
  • user — вы, на все проекты (~/.claude.json).
// .mcp.json
{
  "mcpServers": {
    "github": {
      "type": "stdio",
      "command": "/path/to/github-mcp-server",
      "env": { "GITHUB_TOKEN": "..." }
    },
    "internal-api": { "type": "http", "url": "https://api.company.com/mcp" }
  }
}

Каждый сервер приносит tools (действия), resources (данные для чтения), prompts (шаблоны). Для многих нужна авторизация (OAuth 2.1 / токены) — секреты хранятся в системном keychain/credentials, а не в конфиге. Управление серверами в сессии — команда /mcp.

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


Skills (навыки)

Skills (Agent Skills) — переиспользуемые пакеты инструкций под конкретные задачи. Каждый навык — папка с файлом SKILL.md: YAML-заголовок (метаданные) + тело с инструкциями; рядом могут лежать вспомогательные файлы/скрипты.

---
name: "Оформление документов"
description: "Когда просят создать .docx/.pptx/.xlsx в фирменном стиле компании"
allowed-tools: ["Bash", "Write"]  # опционально
model: "claude-sonnet"          # опционально
---

## Инструкции
Как собирать документ, шаблоны, требования к стилю, примеры...

Progressive disclosure (постепенное раскрытие) — ключевая идея экономии контекста, в три уровня:

  1. При старте в контекст попадают только name + description каждого навыка (~сотня токенов) — Claude знает, что навыки существуют.
  2. Когда description совпал с задачей — подгружается полный SKILL.md.
  3. Дополнительные файлы навыка читаются только по необходимости.

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

Где лежат: .claude/skills/ (проектные), ~/.claude/skills/ (личные), а также в составе плагинов (plugin skills). Навыки переносимы между Claude Code, Cowork и API.

Отличие от CLAUDE.md: CLAUDE.md — общий постоянный контекст проекта (грузится всегда); Skill — специализированная инструкция под тип задачи, подключается по триггеру. В этом проекте, например, использовались навыки сборки .docx/.pptx/.xlsx и генерации PDF.


Subagents (субагенты)

Subagent (субагент) — отдельный агент со своим системным промптом, изолированным контекстом и (обычно) своим набором инструментов/моделью, которому основной Claude делегирует подзадачу. Субагент не видит историю главной сессии и возвращает в неё только итоговый результат.

Зачем:

  • Экономия контекста — тяжёлый поиск/чтение множества файлов делает субагент, а в основной диалог попадает лишь вывод (не «замусоривает» главный контекст).
  • Специализация — роли: «исследователь кода», «ревьюер», «планировщик», «тестировщик» — каждый со своим промптом и правами.
  • Параллельность — независимые подзадачи запускаются одновременно.

Настраиваются файлами в .claude/agents/*.md (проектные) или ~/.claude/agents/*.md (личные) — YAML-заголовок + системный промпт:

---
name: "Code Reviewer"
description: "Ревью изменений на безопасность, производительность, edge-cases"
tools: ["Read", "Grep", "WebFetch"]   # ограниченный набор
model: "claude-opus"
maxTurns: 20
---

Ты — придирчивый ревьюер. Проверяй N+1, инъекции, обработку ошибок...

Главный агент по description решает, какому субагенту делегировать (через инструмент Agent, в старых версиях — Task); субагенты не могут порождать своих субагентов (вложенности нет). Список — команда /agents.

В этом проекте субагенты реально использовались — чтобы распараллелить транскрибацию 184 скриншотов кода: несколько агентов читали свои группы картинок и возвращали текст, не раздувая основной контекст (иначе бы всё не поместилось).


Slash-команды

Slash-команды (/команда) — быстрые действия и шаблоны промптов.

Встроенные (частые):

  • /help — справка; /clear — очистить историю; /compact — сжать историю (сохранив суть).
  • /init — сгенерировать CLAUDE.md; /memory — открыть файлы памяти.
  • /model — сменить модель сессии; /config — настройки; /cost — расход токенов.
  • /agents — субагенты; /mcp — MCP-серверы; /review — код-ревью.

Кастомные команды — свои шаблоны в .claude/commands/*.md; поддерживают аргументы через $ARGUMENTS:

<!-- .claude/commands/fix-issue.md -->
Найди и исправь баг из задачи #$ARGUMENTS: воспроизведи, локализуй, поправь, добавь тест.

Вызов: /fix-issue 123. Кастомные команды и навыки во многом пересекаются — навыки более гибкие и автоактивируемые.


Hooks (хуки)

Hooks (хуки) — скрипты, которые Claude Code выполняет на определённые события жизненного цикла. Дают детерминированный контроль над поведением агента (не «уговорами» в промпте, а кодом).

Основные события: PreToolUse (перед вызовом инструмента — можно заблокировать), PostToolUse (после — обработать/залогировать), UserPromptSubmit (при отправке промпта), SessionStart/SessionEnd, Stop/SubagentStop.

Регистрируются в settings.json; событие приходит хуку в stdin (JSON), а код возврата/вывод хука влияет на продолжение: exit 2 блокирует действие (stderr уходит Claude как причина), exit 0 — успех, прочие ненулевые коды — неблокирующая ошибка. Формат: matcher + массив hooks с {type, command}:

{
  "hooks": {
    "PreToolUse": [
      { "matcher": "Bash", "hooks": [{ "type": "command", "command": "bash ./.claude/guard.sh" }] }  // запретить опасные команды (exit 2)
    ],
    "PostToolUse": [
      { "matcher": "Write|Edit", "hooks": [{ "type": "command", "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write" }] }  // автоформат: путь берём из JSON в stdin
    ]
  }
}

Типичные применения: блокировать rm -rf, автоформат/линт после правок, логирование всех инструментов, проверки перед коммитом, загрузка переменных окружения при старте.


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

Плагин (plugin) — устанавливаемый бандл, объединяющий сразу несколько расширений: skills, subagents, slash-команды, hooks и MCP-серверы. Ставится одной командой, что удобно для распространения общих настроек по команде.

Структура плагина: plugin.json (метаданные) + папки skills/, agents/, commands/, hooks/, конфиги MCP.

Маркетплейсы (marketplaces) — каталоги плагинов (официальный от Anthropic и кастомные). Команда один раз подключает маркетплейс (/plugin marketplace add) и ставит плагины — и все получают одинаковый набор навыков/агентов/интеграций.

/plugin marketplace add user/repo   # репозиторий (GitHub/git URL/путь) подключается как маркетплейс
/plugin install <имя>@<маркетплейс>

Так, например, в этом проекте доступны плагины (набор инженерных skills, интеграции с Miro/GitHub/Slack и т.д.) — они добавляют команды, агентов и MCP-инструменты поверх базового Claude Code/Cowork.


Вероятные вопросы

Как в двух словах работает LLM? Предсказывает следующий токен по контексту (Transformer + attention); знания — в весах (отсюда knowledge cutoff и галлюцинации); сама по себе stateless — история диалога передаётся в контексте.

Что такое токен и контекстное окно? Токен — кусочек текста (~0.75 слова). Контекстное окно — макс. число токенов за запрос (вход + выход); в него входит всё: система, история, документы, ответ.

За что отвечает temperature? За случайность вывода: 0 — детерминированно (факты/код), выше — разнообразнее (творчество). Ещё top-p/top-k.

Что такое галлюцинация и как бороться? Уверенно неверный ответ. Снижают через RAG, низкую temperature, требование источников, разрешение «не знаю», валидацию/evals.

Что такое эмбеддинг? Вектор, кодирующий смысл текста; близкие по смыслу тексты — близкие векторы. Основа семантического поиска и RAG; хранят в векторных БД.

Что такое RAG и зачем? Генерация с поиском: вопрос → поиск релевантных чанков в векторной БД → вставка в промпт → ответ по ним. Даёт свежие/приватные/проверяемые знания, снижает галлюцинации.

Из чего состоит RAG-пайплайн? Индексация (чанкинг → эмбеддинги → векторная БД) и запрос (эмбеддинг вопроса → поиск → контекст в промпт → LLM). Важны чанкинг, reranking, гибридный поиск.

Что такое function calling / tool use? Модель возвращает структурированный запрос на вызов функции с аргументами; ваш код выполняет и возвращает результат. Даёт LLM доступ к данным/API/действиям. Сама модель код не выполняет.

Что такое AI-агент? LLM в цикле think→act→observe: сама выбирает инструменты для достижения цели, наблюдает результаты, корректирует план.

Что такое MCP? Открытый протокол-стандарт подключения LLM к внешним инструментам/данным (клиент-сервер: tools/resources/prompts). «USB-C для AI» — переиспользуемые интеграции.

Prompting vs RAG vs fine-tuning? Промптинг — быстро и дёшево (сначала он); RAG — актуальные/приватные знания с проверяемостью; fine-tuning — стабильное поведение/стиль/узкий домен (дорого, не даёт свежих знаний). Часто RAG + fine-tune.

Что такое prompt injection и как защищаться? Подмена инструкций через ввод/данные (в т.ч. indirect — спрятанные в документах). Защита: least privilege, human-in-the-loop, разделение доверенных инструкций и данных, валидация входа/выхода, sandbox.

Что такое evals? Систематическая оценка качества (golden dataset, метрики retrieval/faithfulness, LLM-as-judge, регрессия промптов, мониторинг в проде).

Что такое prompt caching? Кэширование неизменной части промпта (система/документы) — дешевле и быстрее повторные запросы.

Что такое Claude Code? Агентный CLI-инструмент для разработки: Claude с доступом к файлам, терминалу, git — планирует и выполняет задачи в проекте.

Claude Code vs Cowork? Claude Code — для разработчиков (терминал, код); Cowork — desktop-приложение для не-разработчиков (файлы, документы, задачи) на том же движке.

Какие режимы работы? Обычный (спрашивает разрешение на действия), plan mode (только исследует и планирует, потом выполняет по одобрению), auto-accept (без подтверждений), bypass permissions (без запросов — осознанно).

Что такое CLAUDE.md? Файл инструкций/памяти проекта, автоматически учитываемый в каждой сессии: правила, команды, соглашения. Проектный (в git) и пользовательский уровни; экономит повторение контекста.

Что такое Skills? Переиспользуемые пакеты инструкций (SKILL.md) под конкретные задачи; Claude подгружает их по триггеру (progressive disclosure). CLAUDE.md — постоянный общий контекст, Skill — специализированная задача.

Что такое subagent и зачем? Агент со своим изолированным контекстом/промптом/инструментами для подзадачи; экономит контекст главного агента, специализация, параллельность. Настраивается в .claude/agents/.

Что даёт MCP в Claude Code? Подключение внешних сервисов (GitHub, Slack, БД, браузер) как инструментов — расширяет доступ ассистента без переписывания агента.

Что такое плагины и хуки? Хуки — скрипты на события агента (линт/проверки/запреты). Плагины — бандлы из MCP/skills/команд/агентов/хуков (в маркетплейсах) для быстрого расширения.

Как настраиваются разрешения и каков приоритет? В settings.json списки allow/deny/ask + defaultMode; приоритет deny > ask > allow, затем defaultMode. Опасные действия по умолчанию требуют подтверждения.

Чем Claude Agent SDK отличается от Claude Code? Claude Code — интерактивный CLI/IDE/Desktop на машине пользователя; Agent SDK — библиотека (TS/Python) для встраивания того же агента в свою инфраструктуру (программный query(), self-hosted, свои auth/sandbox).

Что такое progressive disclosure у навыков? Трёхуровневая загрузка: сначала только name+description всех навыков (дёшево), при совпадении — полный SKILL.md, затем доп. файлы по необходимости. Позволяет держать десятки навыков без раздувания контекста.

Какие бывают события у хуков? PreToolUse/PostToolUse (до/после инструмента), UserPromptSubmit, SessionStart/SessionEnd, Stop/SubagentStop. Код возврата 2 блокирует действие (прочие ненулевые — неблокирующая ошибка).

Как субагент помогает с контекстом? Работает в изолированном окне, тяжёлую работу (поиск/чтение) делает у себя, а в главный контекст возвращает только итог — главный диалог не переполняется.

CLAUDE.md vs Skill vs subagent — в чём разница? CLAUDE.md — постоянный контекст проекта (всегда в начале сессии); Skill — инструкция под тип задачи, подгружается по триггеру; subagent — отдельный агент с изолированным контекстом под делегированную подзадачу.