Claude Code + Antigravity: от нула до AI оркестратор [2026]

Имате ли чувството, че пишете код по-бавно от AI агента до вас? Не сте сами. През 2026 г. границата между "аз пиша код" и "аз оркестрирам агенти" се размива с всеки изминал ден. А комбинацията Claude Code + Google Antigravity IDE е може би най-мощният инструментариум за разработчици, който съществува днес.

Накратко: Този наръчник ви показва как да настроите Claude Opus 4.6 в терминала на Antigravity IDE, как да организирате проекта си с CLAUDE.md за максимална ефективност на агентите, защо skills замениха slash commands, как да свържете MCP сървъри и SSH, и как да оркестрирате документация като професионалисти. Всичко — стъпка по стъпка, с реални примери.

Какво ви трябва за този наръчник

1. Google акаунт — за Antigravity IDE (безплатен)
2. Claude абонамент — Pro ($20/мес), Max ($100-200/мес) или Enterprise
3. Терминал — вграденият в Antigravity, VS Code, или системен
4. Git — за версионен контрол (Git for Windows на Windows)
5. 10 минути — толкова отнема пълната настройка от нулата

Защо точно Claude Code и Antigravity IDE заедно

Google Antigravity е първото IDE, проектирано изцяло около AI агенти. Обявено на 18 ноември 2025 г. заедно с Gemini 3, то предлага нещо, което нито VS Code, нито Cursor имат — Manager View, контролен център за оркестриране на множество агенти, работещи паралелно в отделни workspace-ове. На SWE-bench Verified платформата постига 76.2% — сред най-високите резултати за coding agent през 2026 г.

Claude Code е терминал-базиран AI агент от Anthropic, задвижван от Claude Opus 4.6 — модел, който при лансирането си на 5 февруари 2026 г. постави рекорд на Terminal-Bench 2.0 (65.4%) и беше лидер на Humanity's Last Exam (53.1%). С 1M контекстен прозорец, 128K max output tokens и adaptive thinking, Opus 4.6 не просто допълва кода ви — той планира, изследва, имплементира и се самокоригира. Anthropic го описват като "the world's best model for coding, enterprise agents, and professional work".

Защо комбинацията е по-мощна от всяка алтернатива

Ключовото предимство е разделението на отговорностите: използвайте Gemini агентите на Antigravity за планиране и архитектура (спестявате Claude токени), а Claude Code за имплементация, дебъгване и code review — там, където качеството на кода е критично. Тази стратегия се потвърждава и от официалните best practices на Claude Code, които препоръчват "Explore first, then plan, then code".

"Claude felt steadier and more structured, reducing friction in our critical validation loops."

Инсталация и настройка стъпка по стъпка

Стъпка 1: Инсталирайте Antigravity IDE

Google Antigravity е безплатен за изтегляне. Базиран е на VS Code, така че интерфейсът ще ви е познат:

1. Изтеглете от официалния сайт на Antigravity
2. Инсталирайте и стартирайте
3. Влезте с вашия Google акаунт

Стъпка 2: Инсталирайте Claude Code CLI

В терминала на Antigravity (или всеки друг терминал):

macOS / Linux:

curl -fsSL https://claude.ai/install.sh | bash

Windows PowerShell:

irm https://claude.ai/install.ps1 | iex

Windows CMD:

curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

Homebrew (macOS):

brew install --cask claude-code

WinGet (Windows):

winget install Anthropic.ClaudeCode

Native инсталациите се обновяват автоматично. Homebrew и WinGet — не: изпълнявайте brew upgrade claude-code или winget upgrade Anthropic.ClaudeCode периодично.

Стъпка 3: Автентикация

Стартирайте Claude Code за първи път:

cd /path/to/your/project
claude

При първото стартиране Claude Code отваря браузър за вход. Поддържа:

• Claude Pro / Max / Team / Enterprise — препоръчително
• Claude Console (API с предплатени кредити)
• Amazon Bedrock / Google Vertex AI / Microsoft Foundry — за enterprise

За headless сървъри без браузър, задайте API ключ:

export CLAUDE_CODE_API_KEY="your-api-key-here"

Или използвайте claude setup-token на локална машина и прехвърлете токена.

Терминалът е вашият главен щаб — основни CLI команди

Claude Code не е чатбот. Той е агент, който чете файлове, изпълнява команди, прави промени и решава проблеми автономно. Ето основните команди:

Pro съвети за терминала

Pipe данни директно в Claude:

cat error.log | claude
git diff | claude "review these changes"
npm test 2>&1 | claude "fix the failing tests"

Non-interactive режим за скриптове и CI/CD:

claude -p "List all API endpoints" --output-format json
claude -p "Analyze this log file" --output-format stream-json

Паралелни сесии за мащабни миграции:

for file in $(cat files.txt); do
  claude -p "Migrate $file from React to Vue. Return OK or FAIL." \
    --allowedTools "Edit,Bash(git commit *)"
done

Auto mode — класификатор проверява командите преди изпълнение, блокирайки само рисковите:

claude --permission-mode auto -p "fix all lint errors"

CLAUDE.md — единственият файл, който трансформира агента ви

Ако има едно нещо, което отличава аматьорското от професионалното използване на Claude Code, това е CLAUDE.md. CLAUDE.md е специален markdown файл, който Claude Code автоматично зарежда в началото на всяка сесия — вашият "контракт" с агента, съдържащ правила, конвенции и контекст, който той не може да изведе от кода.

Къде се поставя CLAUDE.md

Какво да включите (и какво да НЕ включвате)

# Code style
- Use ES modules (import/export), not CommonJS (require)
- Destructure imports when possible

# Workflow
- Always typecheck after code changes
- Run single tests, not the whole suite

# Architecture decisions
- API routes follow /api/v1/{resource} pattern
- All database access goes through the ORM layer

# Gotchas
- The legacy auth module uses callbacks, not promises
- Environment variable API_KEY must be set for tests

Включвайте: Bash команди, които Claude не може да познае; code style различия от defaults; тест инструкции; repo конвенции; архитектурни решения; environment quirks.

НЕ включвайте: Неща, които Claude може да изведе от кода; стандартни езикови конвенции; подробна API документация (линкнете вместо това); информация, която се променя често.

Правилото за 150 инструкции

Има приблизително 150-200 инструкции бюджет преди compliance-ът да започне да пада (системният prompt вече заема около 50). Ако CLAUDE.md е твърде дълъг, Claude ще игнорира половината. Третирайте го като код: ревюирайте го, подрязвайте го, тествайте дали промените работят.

CLAUDE.md поддържа импорти

See @README.md for project overview and @package.json for npm commands.

# Additional Instructions
- Git workflow: @docs/git-instructions.md
- Personal overrides: @~/.claude/my-project-instructions.md

Бонус: CLAUDE.md, GEMINI.md и AGENTS.md — един проект, много агенти

Ако работите с Antigravity IDE, ще забележите, че от v1.20.3 (март 2026) то поддържа AGENTS.md и GEMINI.md rules файлове. Можете да имате и трите в един проект:

• CLAUDE.md — инструкции за Claude Code агентите
• GEMINI.md — инструкции за Gemini агентите в Antigravity
• AGENTS.md — споделени правила, които работят и за двата

Така всеки агент получава контекст, оптимизиран за неговите силни страни, а споделените правила (code style, git conventions, architecture) живеят на едно място.

Защо Skills замениха Slash Commands — и защо това е по-добре

Ако идвате от по-стари версии на Claude Code, помните .claude/commands/*.md файловете. Те все още работят, но са deprecated в полза на Skills — и ето защо.

Какво бяха Commands

Commands бяха markdown файлове, които създаваха /slash-command интерфейс. Проблемът: Claude не можеше да ги извиква автоматично. Те не участваха в "progressive disclosure" — Claude не знаеше за тях, докато вие не ги извикате ръчно.

Какво са Skills

Skills са markdown файлове с YAML frontmatter (.claude/skills/<name>/SKILL.md), които разширяват знанията и възможностите на Claude Code. Те са еволюцията на commands с критични предимства:

• Автоматично зареждане — Claude ги открива и използва, когато са релевантни, без вие да ги извиквате
• Frontmatter контрол — disable-model-invocation, user-invocable, allowed-tools, context, agent, model, effort (low/medium/high)
• Supporting файлове — шаблони, примери, скриптове в директорията на skill-а
• Динамичен контекст — !`command` синтаксис за инжектиране на shell output
• Subagent изпълнение — context: fork за изолиране в отделен контекст

Пример: Skill за deploy

# .claude/skills/deploy/SKILL.md
---
name: deploy
description: Deploy the application to production
disable-model-invocation: true
---

Deploy $ARGUMENTS to production:
1. Run the test suite
2. Build the application
3. Push to the deployment target
4. Verify the deployment succeeded

С disable-model-invocation: true — само вие можете да го извикате с /deploy. Claude няма да реши сам да deploy-не.

Пример: Skill с динамичен контекст

# .claude/skills/pr-summary/SKILL.md
---
name: pr-summary
description: Summarize changes in a pull request
context: fork
agent: Explore
allowed-tools: Bash(gh *)
---

## Pull request context
- PR diff: !`gh pr diff`
- PR comments: !`gh pr view --comments`
- Changed files: !`gh pr diff --name-only`

## Your task
Summarize this pull request...

Shell командите се изпълняват преди Claude да види промпта — той получава вече готовите данни.

MCP: свържете Claude Code с целия свят

Model Context Protocol (MCP) е отворен стандарт за свързване на AI модели с външни инструменти. Мислете за него като USB-C за AI — един конектор за всичко. Ако искате по-задълбочен поглед върху MCP с конкретен пример, вижте нашия наръчник за Claude Code + NotebookLM чрез MCP.

Добавяне на MCP сървър

Една команда в терминала:

claude mcp add --scope project github -- npx -y @modelcontextprotocol/server-github

Или управлявайте с /mcp командата в интерактивен режим.

Два типа транспорт

Забележка: SSE (Server-Sent Events) транспортът е deprecated от април 2026 г. в полза на Streamable HTTP. Ако срещнете стари MCP сървъри, които още ползват SSE, те ще работят за обратна съвместимост, но новите интеграции трябва да ползват Streamable HTTP.

Най-полезни MCP сървъри за разработчици

1. GitHub — управление на repos, PRs, issues от Claude
2. Playwright — браузърна автоматизация и тестване
3. Sentry — мониторинг на production грешки
4. PostgreSQL / Supabase — директен достъп до бази данни
5. Figma — от дизайн към код
6. Brave Search — уеб търсене от агента
7. NotebookLM — изследване с citation-backed отговори

Claude Code КАТО MCP сървър

Claude Code може да работи и в обратната посока — като MCP сървър за други клиенти:

claude mcp serve

Това expose-ва инструментите за редактиране на файлове и изпълнение на команди чрез MCP протокола.

SSH и Remote Development — AI агент на всеки сървър

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

Headless режим на VPS

# Non-interactive режим — обработва prompt-а и спира
claude -p "fix all failing tests" --output-format json

# С API ключ за автентикация (без браузър)
export CLAUDE_CODE_API_KEY="sk-ant-..."
claude -p "deploy to staging"

Remote Control чрез SSH + tmux

Стартирайте Claude Code на сървъра в tmux сесия и го контролирайте от всяко устройство:

# На сървъра
tmux new -s claude-session
claude

# От друга машина — свържете се
ssh user@server -t "tmux attach -t claude-session"

Изисквания

• Минимум 4 GB свободна RAM
• Node.js 20+ (или native installer — не изисква Node.js)
• Git за версионен контрол

Hooks: детерминистична автоматизация на работния процес

Hooks са детерминистични shell команди, конфигурирани в .claude/settings.json, които се изпълняват автоматично в конкретни точки от жизнения цикъл на Claude Code. За разлика от инструкциите в CLAUDE.md (които са препоръчителни), hooks са детерминистични — гарантирано се изпълняват всеки път.

Ключови Hook събития

Пример: auto-format след всяко редактиране

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write"
          }
        ]
      }
    ]
  }
}

Всеки hook получава JSON на stdin с данни за инструмента. jq извлича пътя до файла, а xargs го подава на Prettier.

Пример: блокиране на промени в migrations

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | grep -q 'migrations/' && echo '{\"hookSpecificOutput\":{\"hookEventName\":\"PreToolUse\",\"permissionDecision\":\"deny\",\"permissionDecisionReason\":\"Migrations are locked\"}}' || echo '{}'"
          }
        ]
      }
    ]
  }
}

Hook с permissionDecision: "deny" блокира действието дори в auto mode или с --dangerously-skip-permissions. Обърнете внимание на hookSpecificOutput обвивката — тя е задължителна за structured JSON output.

Claude може да пише hooks вместо вас — опитайте: "Write a hook that runs eslint after every file edit".

Оркестрация на документация — изграждайте проекти като специалисти

Защо стриктната документация не е опция, а необходимост

AI агентите са мощни, но без ясни правила те се отклоняват от целта на проекта. Ето какво се случва без добра документация:

• Context drift — при дълги сесии агентът постепенно "забравя" архитектурните решения, взети в началото. Без CLAUDE.md, който ги припомня при всяка нова сесия, агентът може да въведе patterns, които противоречат на вече съществуващия код
• Inconsistency при паралелна работа — ако двама разработчици (или два агента) работят едновременно без споделени конвенции, резултатът е код в два различни стила, с различни error handling подходи и несъвместими абстракции
• Hallucination amplification — агент без контекст за вашия проект ще измисли архитектурни решения, API endpoints, или database schemas, които звучат правилно, но не съответстват на реалността. CLAUDE.md е vaccinator-ът срещу халюцинации на проектно ниво
• Scope creep — без ясни граници агентът може да "подобри" код, който не е поискан, да добави features, които не съществуват в спецификацията, или да рефакторира модули, които не трябва да се пипат
• Knowledge loss — когато сесията свърши, контекстът изчезва. Ако научените решения не са записани в документацията, следващата сесия започва от нулата

Както казват в официалните best practices на Anthropic: "Context window fills up fast, and performance degrades as it fills." Документацията е вашата защита срещу тази деградация — тя гарантира, че агентът винаги знае какво е проектът, как се работи по него и какво НЕ трябва да прави.

Ето системата, която ни позволява да поддържаме перфектна документация на всеки проект:

Структура на документацията

project/
  CLAUDE.md              # Главни инструкции за агента
  CLAUDE.local.md        # Лични настройки (в .gitignore)
  PLAN.md                # Архитектура и технически план
  .claude/
    skills/              # Reusable workflows
      deploy/SKILL.md
      review-pr/SKILL.md
      fix-issue/SKILL.md
    agents/              # Custom subagents
      security-reviewer.md
      test-writer.md
    settings.json        # Hooks, permissions, MCP config
  docs/
    ARCHITECTURE.md      # Диаграми и design decisions
    API.md               # API документация
    CHANGELOG.md         # История на промените

Принцип 1: Progressive Disclosure

Не слагайте всичко в CLAUDE.md. Използвайте skills за специфични workflow-ове, subagents за специализирани задачи, и child CLAUDE.md файлове за поддиректории. Claude зарежда само това, което е нужно за текущата задача.

Принцип 2: Separation of Concerns

• CLAUDE.md — глобални правила, code style, workflow стъпки
• Skills — повторяеми задачи (deploy, PR review, issue fixing)
• Subagents — специализирани роли (security review, test writing)
• Hooks — неща, които ТРЯБВА да се случат (formatting, validation)

Принцип 3: Context е най-ценният ресурс

Контекстният прозорец се пълни бързо. Ефективните практики:

• /clear между несвързани задачи
• /compact за компресиране на дълги сесии
• Subagents за изследвания — те работят в отделен контекст
• /btw за бързи въпроси без натрупване на контекст
• Checkpoint-и — двоен Esc за връщане назад

Принцип 4: Agent Teams — множество агенти в координация

Agent Teams е една от най-мощните функции на Claude Code (research preview от v2.1.32). Вместо ръчно да управлявате паралелни сесии, Agent Teams автоматизира координацията:

• Множество Claude инстанции работят паралелно в отделни git worktrees
• Агентите claim-ват задачи, merge-ват промени и решават конфликти автоматично
• Един "team lead" агент координира останалите

# Стартирайте agent team от CLI
claude --worktree feature-auth --tmux

Или използвайте Writer/Reviewer pattern ръчно с две паралелни сесии:

Друга опция: /batch — оркестрира мащабни промени автоматично. Анализира codebase-а, разделя работата на 5-30 независими единици и стартира по един агент за всяка в изолиран worktree:

/batch migrate all React class components to functional components with hooks

Принцип 5: Custom Subagents за вашия екип

# .claude/agents/security-reviewer.md
---
name: security-reviewer
description: Reviews code for security vulnerabilities
tools: Read, Grep, Glob, Bash
model: opus
---
You are a senior security engineer. Review code for:
- Injection vulnerabilities (SQL, XSS, command injection)
- Authentication and authorization flaws
- Secrets or credentials in code
- Insecure data handling

Provide specific line references and suggested fixes.

Workflow за максимална ефективност — пълният цикъл

Ето как изглежда един професионален работен ден с тази комбинация:

1. Сутрин: Планиране с Antigravity

Използвайте Manager View на Antigravity с Gemini агент за планиране:

• Прегледайте issues, определете приоритети
• Нека Gemini агент анализира архитектурата и предложи подход
• Спестявате Claude токени за имплементацията

2. Имплементация с Claude Code

Превключете към терминала:

claude
> Read the plan in PLAN.md. Implement feature X following our conventions.
> Write tests, run them, fix failures.

3. Code Review с Subagent

> Use a subagent to review the changes for edge cases and security issues.

4. Commit и PR

> Commit with a descriptive message and open a PR.

5. Документация

Claude автоматично знае от CLAUDE.md да обнови CHANGELOG, да добави JSDoc коментари, и да провери дали архитектурните решения са отразени.

Практически съвети за продуктивност с AI агенти

Бъдете конкретни

# Лошо
fix the bug

# Добро
Fix the login bug where users see a blank screen after
entering wrong credentials. Check src/auth/ for token refresh.
Write a failing test first, then fix it.

Използвайте Plan Mode за сложни задачи

Въведете /plan или натиснете Shift+Tab (на macOS/Linux; на Windows има known issue — ползвайте /plan) за Plan Mode — Claude чете файлове и отговаря на въпроси без да прави промени. Перфектен за exploration преди имплементация.

Инвестирайте във верификация

Единственият най-ефективен съвет: дайте на Claude начин да провери работата си. Тестове, скрийншотове, linter output — всичко, което затваря feedback loop. За повече техники вижте нашето ръководство за prompt инженерство.

Именувайте сесиите си

Използвайте /rename oauth-migration за да намерите сесиите по-лесно с claude --resume.

Chrome интеграция за UI тестване

Стартирайте с claude --chrome и Claude може да отваря tabs в браузъра, да тества UI, да прави скрийншотове и да итерира, докато резултатът не съвпадне с очакванията. Перфектно за верификация на frontend промени.

CLI инструменти = контекстна ефективност

Инсталирайте gh (GitHub CLI), aws, gcloud, sentry-cli. Claude ги познава и ги използва ефективно. За непознати инструменти:

Use 'foo-cli-tool --help' to learn about foo tool,
then use it to solve A, B, C.

Plugins — разширения с едно действие

Въведете /plugin за marketplace с готови разширения. Plugins пакетират skills, hooks, subagents и MCP сървъри в една инсталация. За typed езици (TypeScript, Java) — code intelligence plugins дават на Claude прецизна навигация по символи и автоматично засичане на грешки след всяка редакция.

Заключение: бъдещето на разработката е агентно

Комбинацията Claude Code + Google Antigravity IDE не е просто "още един AI инструмент". Това е нов модел на работа — вие оркестрирате, агентите изпълняват.

С правилно конфигуриран CLAUDE.md, добре написани skills, стратегически свързани MCP сървъри и hooks за автоматизация, вие не просто пишете код — вие управлявате екип от AI агенти, които планират, имплементират, тестват и документират.

Ключът е в организацията на проекта и документацията:

• CLAUDE.md — вашият контракт с агента (глобални правила, code style)
• Skills — стандартни оперативни процедури (deploy, review, fix-issue)
• Hooks — непреговорими правила (formatting, validation, security)
• MCP — интеграционна шина към света (GitHub, DB, Figma, Sentry)
• Subagents — специализирани роли (security reviewer, test writer)

Следващи стъпки

1. Днес: Инсталирайте Claude Code и създайте CLAUDE.md с /init
2. Тази седмица: Добавете 2-3 skills за най-честите ви workflow-ове
3. Този месец: Свържете MCP сървъри и настройте hooks за auto-formatting
4. Постоянно: Подрязвайте CLAUDE.md, ревюирайте skills, управлявайте контекста

Ако искате да разберете по-широката картина на vibe coding и AI агентите в програмирането, вече сме ви подготвили задълбочен анализ. Агентното бъдеще не идва — то вече е тук.