Как работи Claude Code
Здравейте!
В сайта ми вече има три статии за Claude Code: справочник с команди и настройки, разбор на хуковете и практики за работа. И трите отговарят на въпроса „какво да натисна и как да го настроя“. Тази отговаря на друг въпрос: как е устроено отвътре.
Защо е добре да го знаете. Claude Code прилича на чат в терминала, но зад чата стои доста голяма машина: десетки инструменти, няколко вида памет, правила, скилове, субагенти, хукове, разрешения, пясъчник, фонови и облачни сесии. Докато не разберете как са свързани тези части, настройките изглеждат като набор от случайни превключватели. Щом го разберете, повечето от тях стават очевидни.
Статията върви от простото към сложното. Първо – какво става между вашето съобщение и отговора. После – с какво агентът чете, редактира и търси. После – всичко, което живее в папката на проекта и в домашната папка на диска. После – сигурността и изолацията. И накрая – къде може да се стартира всичко това: от лаптопа до виртуална машина в мрежата, и с какво Claude Code се различава от сходните инструменти.
Всичко описано е сверено с официалната документация и с инсталираната при мен версия 2.1.328 през ноември 2026 г. Claude Code излиза по няколко пъти седмично, затова дребните детайли се променят бързо, а устройството като цяло – бавно. Пътищата на диска показвам така, както изглеждат при мен на Windows, и до тях казвам къде е същото на macOS и Linux.
Модел и харнес: кой какво прави
Започваме с най-важното разделение. В Claude Code има две части и постоянно ги бъркат.
Моделът е невронната мрежа Claude на сървърите на Anthropic. Тя умее едно нещо: получава текст и връща текст. Не вижда вашия диск, не може да стартира команда и нищо не помни между заявките.
Харнесът (harness, „обвивка“) е програмата claude, която работи на вашия компютър. Именно нея инсталирате. Тя чете файлове, стартира команди, показва интерфейса, пита за разрешения, пази историята и решава какво да изпрати на модела във всяка заявка.
Моделът мисли, харнесът действа. Свързани са чрез инструменти (tools). Инструментът е функция, която харнесът умее да изпълни: „прочети файл“, „стартирай команда“, „намери низ“. Харнесът описва на модела списък с инструменти, а моделът в отговора си може да напише не обикновен текст, а молба: „извикай инструмента за четене с такъв и такъв път“. Харнесът изпълнява молбата и връща на модела резултата.
вашият компютър сървърите на Anthropic┌──────────────────────────────┐ ┌────────────────────┐│ харнес (програма claude) │ заявка → │ ││ │ │ модел Claude ││ интерфейс, разрешения, │ ← отговор │ ││ история, настройки │ └────────────────────┘│ │ ││ инструменти ││ ┌─────────┬───────┬───────┐ ││ │ файлове │ shell │ уеб │ ││ └─────────┴───────┴───────┘ │└──────────────────────────────┘От тази схема следва изводът, който ще ни трябва още много пъти. Вашият код не се „качва в Claude“. Той си стои на диска, а към сървърите отива само онова, което харнесът е сложил в заявката: вашите съобщения, прочетените файлове, изходът на командите. Всичко останало моделът не го е виждал.
И втори извод. Един и същ модел работи различно в различните харнеси, защото те имат различни инструменти, различни системни инструкции и различно устроена работа с контекста. Колко силно това влияе на резултата, разглеждах в сравнението на харнесите.
Цикълът на агента: какво става след Enter
Обикновеният чат е устроен така: въпрос – отговор. Агентът е устроен иначе: въпрос – много стъпки – отговор. Тези стъпки се наричат цикъл на агента.
Ще го разгледаме на пример. Написали сте: „тестът за автентикация пада, оправи го“.
- Харнесът сглобява заявката: системните инструкции, описанията на инструментите, инструкциите на проекта, вашата фраза. Изпраща я на модела.
- Моделът отговаря не с текст, а с извикване на инструмент: „стартирай тестовете за автентикация“.
- Харнесът проверява дали това може да се прави без питане. Ако не може – пита вас. После стартира командата и получава изхода.
- Харнесът изпраща на модела нова заявка: всичко предишно плюс изхода от тестовете.
- Моделът вижда грешката и моли да се намери в кода функцията, която е паднала. Харнесът търси и връща резултата.
- Моделът моли да се прочете файл. После моли да се замени в него един ред с друг. После пак да се стартират тестовете.
- Тестовете минават. Моделът отговаря с обикновен текст: какво е било не наред и какво е поправил. В отговора няма извиквания на инструменти – ходът е приключил.
Документацията описва този цикъл с три фази: събиране на контекст → действие → проверка на резултата. Фазите не вървят строго една след друга: какво да прави нататък, моделът решава след всяка стъпка, като гледа какво е върнала предишната.
Три детайла, които е добре да знаете.
Всяка заявка носи целия разговор. Моделът нищо не помни между заявките, затова на стъпка 6 харнесът изпраща наново всичко от стъпка 1. От тук расте цялата тема за контекста, свиването и цената – за нея по-долу.
Извикванията могат да са паралелни. Ако моделът трябва да прочете пет файла, той моли и петте в един отговор, а харнесът ги изпълнява едновременно.
Можете да се намесите по всяко време. Esc спира текущото извикване и връща управлението на вас. А ако просто напишете съобщение, докато агентът работи, той ще го прочете след текущите извиквания, в същия ход. Това е удобен начин да коригирате курса, без да прекъсвате работата.
Какво вижда моделът в началото на сесията
Преди първото ви съобщение в заявката вече има доста неща. Важно е да разберете какви точно, защото всеки ред там се плаща във всяка заявка и влияе на поведението.
| Какво | Откъде идва | Кога се зарежда |
|---|---|---|
| Системен промпт | вграден в Claude Code | винаги |
| Описания на вградените инструменти | вградени | винаги |
| Сведения за средата | работна папка, ОС, клон на git, некомитнати промени, последни комити | винаги |
| Инструкции на проекта | файловете CLAUDE.md и правилата без връзка с пътища | винаги |
| Автоматична памет | началото на файла MEMORY.md | винаги |
| Списък със скилове | само името и описанието на всеки | винаги; тялото – при извикване |
| MCP сървъри | само имената на инструментите и инструкциите на сървъра | винаги; схемите – при поискване |
| Стил на изхода | избраният output style | ако е зададен |
Една тънкост за инструкциите на проекта. CLAUDE.md не става част от системния промпт. Той стига до модела като съобщение на потребителя веднага след системния промпт. Затова това са именно инструкции, които моделът обикновено следва, а не твърда конфигурация. За онова, което трябва да се изпълнява винаги и без изключения, има хукове и правила за разрешенията – механизми на харнеса, а не на текста.
Какво съставя контекста в момента, можете да видите с командата /context: тя рисува мрежа и показва колко място заемат инструментите, паметта, скиловете и самият разговор.
Инструменти: с какво работи агентът
Инструментите са над тридесет. Не е нужно да ги запомняте всички, но основните е полезно да знаете по име: същите имена се пишат в правилата за разрешенията и в хуковете.
| Група | Инструменти | Питат ли за разрешение |
|---|---|---|
| Файлове | Read, Edit, Write, NotebookEdit | четенето – не, редактирането – да |
| Търсене | Grep, Glob, LSP | не |
| Команди | Bash, PowerShell, Monitor | да, освен за очевидно безопасните команди |
| Уеб | WebFetch, WebSearch | да |
| Агенти | Agent, SendMessage, ListAgents, Workflow | предимно не |
| Планиране | EnterPlanMode, ExitPlanMode, TaskCreate и други, AskUserQuestion | не |
| Разширения | Skill, ToolSearch, инструментите на MCP сървърите | зависи от скила и сървъра |
| График | CronCreate, CronList, CronDelete, ScheduleWakeup | не |
| Работни копия | EnterWorktree, ExitWorktree | влизането – да |
Сега по ред за онези, от които се състои почти цялата работа.
Четене на файлове
Всички примери в този раздел са снети от малък учебен проект. В него има пет файла: модул за сесии, два обработчика на API, тест и събран бандъл в папката dist, която е добавена в .gitignore.
demo/├── .gitignore node_modules/ и dist/├── dist/bundle.js├── src/│ ├── auth/session.ts│ └── api/│ ├── login.ts│ └── profile.ts└── tests/session.test.tsИзвикването на инструмент е JSON с параметри: именно в такъв вид го изпраща моделът, а името на инструмента подписвам над блока. Нов ред вътре в стойност се записва като \n, това е обикновеното правило на JSON. Отговорите са показани такива, каквито ги е върнал харнесът; дългите абсолютни пътища са съкратени до относителни.
Read приема път към файл и връща съдържанието му. Пред всеки ред вляво стои номерът му:
{ "file_path": "src/auth/session.ts"}1 import { db } from '../db';23 const TTL = 60 * 60;45 export function createSession(userId: string) {6 const token = crypto.randomUUID();7 db.sessions.insert({ token, userId, expiresAt: Date.now() + TTL * 1000 });8 return token;9 }1011 export function findSession(token: string) {12 const session = db.sessions.find(token);13 if (!session) {14 return null;15 }16 if (session.expiresAt < Date.now()) {17 return null;18 }19 return session;20 }Номерата на редовете трябват на модела, за да се ориентира и да сочи място във файла. В самия файл те, разбира се, не влизат, и при редактиране моделът е длъжен да ги отхвърли.
Няма смисъл да се чете цял голям файл. Read има два незадължителни параметъра: от кой ред да започне и колко реда да вземе. Така агентът чете само нужната функция:
{ "file_path": "src/auth/session.ts", "offset": 11, "limit": 6}11 export function findSession(token: string) {12 const session = db.sessions.find(token);13 if (!session) {14 return null;15 }16 if (session.expiresAt < Date.now()) {Обикновено изглежда така: търсенето съобщава, че нужното се намира на ред 340 във файл от две хиляди реда, и агентът чете редовете от 320 до 380, а не целия файл.
Ограниченията са такива. При едно извикване се връщат до 25 хиляди токена. Файл над 256 КБ не се чете цял без изрично указание: агентът ще получи отказ и ще го прочете на части. Ако файлът не съществува, отговорът е обикновена грешка, а моделът я вижда като резултат от извикването:
File does not exist. Note: your current working directory is D:\projects\demo.На тази подсказка за работната папка си струва да обърнете внимание. Най-честата причина за такава грешка е относителен път, пресметнат не от същата папка. Затова инструментите за работа с файлове изискват абсолютни пътища.
Read чете не само текст. Картинката (PNG, JPEG, GIF, WebP) моделът ще я види като изображение: така агентът гледа екранни снимки и макети. PDF се чете по страници, блокнотът на Jupyter – по клетки заедно с изхода. Двоични формати като .xlsx или .zip инструментът не отваря: за тях агентът пише малък скрипт.
Редактиране: точна замяна на низ
Това е най-неочевидната част и на нея си струва да се спрем.
Агентът не пренаписва файла целия и не създава пач във формат diff. Инструментът Edit приема три неща: път, старо парче и ново парче. Харнесът намира във файла старото парче и го заменя с новото.
Най-простият случай е да се смени един ред. Сесията трябва да живее едно денонощие, а не един час:
{ "file_path": "src/auth/session.ts", "old_string": "const TTL = 60 * 60;", "new_string": "const TTL = 60 * 60 * 24;"}The file src/auth/session.ts has been updated successfully.Отговорът е кратък: съдържанието на файла не се връща обратно. Моделът и без това знае какво има сега във файла, защото сам е написал новото парче.
В тази схема има три правила и трите са защита от тиха повреда на кода. Ще разгледаме всяко на пример.
Първо правило: съвпадението е точно. Никакви регулярни изрази и „горе-долу подобно“. Да допуснем, че моделът по памет е решил, че във файла пише const TTL = 3600;:
{ "file_path": "src/auth/session.ts", "old_string": "const TTL = 3600;", "new_string": "const TTL = 86400;"}String to replace not found in file.String: const TTL = 3600;Редакцията не е приложена, файлът не е пипнат. Моделът вижда грешката, препрочита файла и повтаря извикването вече с истинския текст. Същото ще стане, ако се различава поне един интервал в отстъпа или вместо интервали има табулация. Отстрани това дразни, но алтернативата е по-лоша: „умна“ замяна по приблизително съвпадение понякога би попадала на грешното място и бихте разбрали за това след седмица.
Второ правило: парчето трябва да се среща във файла веднъж. В нашия файл редът return null; го има два пъти. Да опитаме да го заменим:
{ "file_path": "src/auth/session.ts", "old_string": " return null;", "new_string": " return undefined;"}Found 2 matches of the string to replace, but replace_all is false.To replace all occurrences, set replace_all to true. To replace only oneoccurrence, please provide more context to uniquely identify the instance.String: return null;Харнесът не се опита да налучква кое от двете места се има предвид. Нататък моделът има два пътя.
Ако трябва едно конкретно място, той взема в old_string повече околен код – толкова, че парчето да стане единствено. Например трябва да се изтрива изтеклата сесия преди връщането. Реда return null; моделът го хваща заедно с условието над него:
{ "file_path": "src/auth/session.ts", "old_string": " if (session.expiresAt < Date.now()) {\n return null;", "new_string": " if (session.expiresAt < Date.now()) {\n db.sessions.delete(token);\n return null;"}Сега парчето от два реда се среща във файла веднъж и редакцията минава. Обърнете внимание, че new_string повтаря непроменените редове: инструментът не „вмъква ред“, той заменя едно парче текст с друго.
Ако пък трябват всички срещания – например при преименуване на променлива в рамките на файла – моделът вдига флаг:
{ "file_path": "src/auth/session.ts", "old_string": "session", "new_string": "userSession", "replace_all": true}Тук се вижда и уловката: такава замяна ще засегне и db.sessions, като го превърне в db.userSessions. Замяната е текстова, за синтаксиса на езика не знае нищо. Затова за преименувания в целия проект агентът обикновено взема инструмент на езиковия сървър, а не текстова замяна.
Трето правило: първо да се прочете, после да се редактира. Първоначално то беше строго: редакция на файл, който не е бил четен в този разговор, се отхвърляше. Смисълът е моделът да редактира това, което наистина има на диска, а не това, което му се струва. При най-новите модели изискването е смекчено: ако съдържанието вече е известно – от изхода на търсене или на команда cat – отделно четене не е задължително. При по-старите модели то се изисква винаги, а за блокнотите на Jupyter и за файловете, прочетени само частично – при всякакви.
От тук следва още една защита. Ако между четенето и редакцията файлът се е променил на диска – запазили сте го в редактора или е сработил форматерът – парчето от old_string може вече да не се намери, и редакцията честно ще падне с грешка „не е намерено“, вместо да изтрие вашите промени.
Няколко редакции в един файл са няколко извиквания подред. Всяко следващо работи вече с променения файл. Затова моделът внимава втората редакция да не търси текст, който първата току-що е заменила.
Защо не diff. Форматът diff изисква от модела точно да пресметне номерата на редовете, а в сметките моделите грешат. Замяната „намери този текст“ изобщо не иска номера, и грешката при нея винаги е силна: или парчето е намерено точно веднъж, или редакция няма.
Създаване и презапис: Write
Write приема път и пълно съдържание. Ако файлът не съществува, той се създава заедно с липсващите папки. Ако съществува – презаписва се изцяло.
{ "file_path": "src/auth/cleanup.ts", "content": "import { db } from '../db';\n\nexport function removeExpired() {\n db.sessions.deleteWhere((s) => s.expiresAt < Date.now());\n}\n"}Да се добави в края на файла с този инструмент не може: той винаги слага целия текст. Затова за редактиране на съществуващ файл почти винаги се избира Edit, и то по две причини. Първо, цената: за да смени един ред във файл от хиляда реда през Write, моделът би трябвало отново да напечата цялата хилядарка. Второ, рискът: докато преписва голям файл, моделът може незабележимо да загуби или да „подобри“ парче, което не са му искали да пипа. Edit физически не може да промени нищо освен назованото парче.
Write остава за два случая: нов файл и пълно пренаписване, когато от старото съдържание почти нищо не остава.
Изтриване, преименуване, преместване
За това няма отделни инструменти. Да изтрие файл, да го преименува или да го премести в друга папка, агентът може само с команда на обвивката: rm, mv, git mv. Това е важно по две причини. Такива действия минават през разрешенията за команди, а не за редакции. И връщането назад по чекпойнтите не ги вижда – за това в раздела за връщането назад.
Какво виждате в интерфейса
Всяка редакция харнесът я показва като познатия diff: в червено премахнатите редове, в зелено добавените. В ръчен режим под него има въпрос с три варианта: да се приложи, да се приложи и повече да не се пита за редакции в тази сесия, да се откаже с обяснение на агента какво не е наред. Откажът с обяснение е нормален работен инструмент: агентът получава вашия текст като резултат от извикването и постъпва иначе.
Ако е отворена IDE с разширение, diff-ът се показва в прозореца на редактора, а не в терминала.
А преди всяка редакция харнесът запазва предишната версия на файла – за това в раздела за връщането назад.
Търсене: няма индекс
Мнозина очакват агентът при първото стартиране да „индексира проекта“: да изгради база с ембединги или граф на кода, както правят някои редактори. Claude Code не го прави. Постоянен индекс той няма.
Вместо това агентът търси така, както би търсил човек в терминала, само че по-бързо и по-упорито:
Инструментите за търсене са два: единият търси файлове по име, другият – по съдържание.
Glob – търсене по име. Приема маска за път и връща списък с файлове:
{ "pattern": "**/*.ts"}src/auth/session.tssrc/api/login.tssrc/api/profile.tstests/session.test.tsДвете звездички значат „на всякаква дълбочина на вложеност“. Резултатът е сортиран по време на промяна и се връщат не повече от сто файла. Типични маски: src/**/*.test.ts – всички тестове, **/package.json – всички пакети на монорепото, **/*config* – всичко, което прилича на конфигурация.
Grep – търсене по съдържание. Приема регулярен израз. Отвътре това е ripgrep, много бърза помощна програма за търсене. Има три режима и агентът ги избира последователно, от евтиния към подробния.
Първият режим е само имената на файловете. Той е включен по подразбиране и почти нищо не струва в токени. Въпросът „къде изобщо се използва тази функция“:
{ "pattern": "findSession"}Found 3 filestests/session.test.tssrc/api/profile.tssrc/auth/session.tsОбърнете внимание: в папката dist има бандъл, където тази дума също я има, но в резултата той не е попаднал. Папката е добавена в .gitignore, а Grep пропуска игнорираните файлове.
Вторият режим са самите редове с номера и със съседни редове за контекст. Тук търсенето се стеснява с маска: само изходният код, без тестовете. Скобата в образеца е екранирана, защото това е регулярен израз:
{ "pattern": "findSession\\(", "glob": "src/**/*.ts", "output_mode": "content", "-C": 1}src/api/profile.ts-3-export function profile(token: string) {src/api/profile.ts:4: const session = findSession(token);src/api/profile.ts-5- return session ? { userId: session.userId } : null;--src/auth/session.ts-10-src/auth/session.ts:11:export function findSession(token: string) {src/auth/session.ts-12- const session = db.sessions.find(token);Редът с двоеточията е съвпадението, редовете с тиретата са контекстът около него. Параметърът -C: 1 означава един ред преди и един след. Това често стига, за да се разбере мястото, без да се отваря файлът.
Третият режим е броят. Въпросът „колко пъти се среща това“:
{ "pattern": "return null", "output_mode": "count"}src/auth/session.ts:2
Found 2 total occurrences across 1 file.Така агентът оценява мащаба още преди да започне: едно е да поправи две места, съвсем друго – двеста.
Нататък агентът чете намереното и, ако трябва, търси пак, вече по-точно. При реална задача това е верига от няколко стъпки: да намери дефиницията на функцията → да намери кой я извиква → да прочете извикващия код → да намери тестовете.
Такъв подход се нарича агентно търсене. Има си цена: всяко търсене е стъпка от цикъла и токени. И има предимства: няма индекс, който да остарява, резултатът винаги съответства на диска и нищо от вашия код не отива в чужда база.
Два детайла, които спестяват време, когато агентът „не намира очевидното“:
Grepпропуска файловете от.gitignore.Globпо подразбиране не ги пропуска. Затова файл от игнорирана папка се намира по име, но не и по съдържание.- На macOS, Linux и в WSL отделни инструменти
GrepиGlobв набора няма: там агентът ползва командитеfindиgrepпрез shell, а Claude Code подменя под тях вградени бързи реализации. На Windows това са отделни инструменти. Поведението е едно, имената в логовете са различни.
Ако искате именно семантика – „намери всички места, където се извиква този метод“, а не „намери текст“ – за целта има инструментът LSP. Той свързва езиков сървър, същия, който работи във вашата IDE, и дава преход към дефиницията, търсене на референции и грешки в типовете веднага след редакция. Включва се с плъгин за конкретен език; за това в раздела за плъгините.
Команди: Bash и PowerShell
Bash изпълнява команда на обвивката и връща изхода. Чрез него агентът прави всичко, за което няма отделен инструмент: билд, тестове, git, пакетни мениджъри, скриптове.
Как се държи:
- Всяка команда е отделен процес. Променливите на средата не се прехвърлят от една команда в следващата. Работната папка се прехвърля, докато сте вътре в проекта; излезете ли извън него, следващата команда пак стартира от проекта.
- Вашият профил се подхваща. При старта на сесията Claude Code снема снимка на вашата обвивка – алиаси, функции, настройки – и я прилага към командите.
- Има таймаут. По подразбиране две минути, моделът може да поиска до десет.
- Дългото отива на фон. Билд или сървър агентът ги стартира на фон и продължава да работи; когато процесът завърши, харнесът му съобщава. Команда, която не се е вместила в таймаута, също минава на фон сама.
- Изходът се отрязва. На модела веднага се предоставят около 30 хиляди символа. Останалото се запазва във файл и агентът чете от него нужните парчета. Така лог от билд с големина един мегабайт не изяжда контекста.
Няколко примера. Ето как изглежда правилото за работната папка. Агентът е преминал във временна директория извън проекта и е изпълнил там команда:
{ "command": "cd /tmp/build && ls"}bundle.jsShell cwd was reset to D:\projects\demoПоследния ред го е добавил харнесът: командата е отработила, но следващата отново ще започне от папката на проекта. Така агентът не може да „се изгуби“ и случайно да изпълни rm не където трябва.
А ето и стартиране на фон. Сървърът за разработка не завършва сам, затова няма смисъл да се чака краят му:
{ "command": "npm run dev", "run_in_background": true}Харнесът веднага връща управлението и идентификатор на фоновата задача. Изходът на сървъра се записва във файл и агентът го чете с обикновения Read, когато трябва да види какво се е случило. Списъкът с фоновите задачи показва командата /tasks; там те могат и да се спрат.
На Windows Bash е Git Bash от Git for Windows. Наред с него работи инструментът PowerShell; без инсталиран Git той остава единствената обвивка. От тук идва типичното объркване: синтаксисът им е различен и команда, написана за едната, в другата не работи.
Има и Monitor: той стартира команда на фон и предава на агента изхода ѝ ред по ред, щом се появи. Удобно е да се следи лог или да се чака събитие, без да се опитва в цикъл.
Команда можете да изпълните и сами, без да излизате от сесията: ред, започнат с !, се стартира в обвивката, а изходът му попада в разговора.
Уеб
WebSearch връща заглавия и адреси от търсещия бекенд на Anthropic. Самите страници той не ги сваля.
WebFetch сваля страница, но работи по-хитро, отколкото изглежда. Той превръща HTML в Markdown и го подава на друга, отделна заявка към малък модел заедно с въпроса. Основният агент получава вече отговор на въпроса, а не суровата страница. Смисълът е двоен: голямата страница не задръства контекста, а вредните инструкции, скрити в текста на страницата, не стигат пряко до основния агент. Обратната страна: това е преразказ и точните цифри от таблица той понякога ги бърка. Когато е нужна дословна точност, на агента е по-добре да свали страницата с команда curl.
За сайтове, които изискват вход или JavaScript, тези два инструмента не стават. Там е нужен истински браузър – за вариантите по-долу.
Една задача цялостно
Сега да съберем инструментите заедно. Задачата е на същия учебен проект: „направи така, че сесията да живее едно денонощие и изтеклите да се изтриват от базата“. Ето какво прави агентът, стъпка по стъпка.
| Стъпка | Извикване | Защо | Какво се върна |
|---|---|---|---|
| 1 | Grep по думата TTL | да се намери къде е зададен срокът на живот | един файл: модулът за сесии |
| 2 | Read на този файл | да се види кодът цял, той е къс | двайсет реда с номера |
| 3 | Grep по findSession | да се разбере кого ще засегне промяната | три файла: самият модул, обработчикът на профила, тестът |
| 4 | Read на обработчика и на теста, с две извиквания наведнъж | да се провери какво очакват от функцията | двата файла |
| 5 | Edit: редът с TTL | денонощие вместо час | „updated successfully“ |
| 6 | Edit: условието за изтекла сесия | да се добави изтриване | „updated successfully“ |
| 7 | Bash: стартиране на тестовете | да се провери резултатът | изходът от тестовете |
| 8 | отговор с текст | да разкаже какво е направено | — |
На какво тук си струва да обърнете внимание.
Агентът започна с търсене, а не с четене на всичко подред. В проект с хиляда файла той по същия начин би прочел три.
Стъпка 3 е направена преди редакцията. Преди да промени поведението на функцията, агентът е изяснил кой я използва. Ако обработчикът на профила разчиташе на това, че изтеклата сесия остава в базата, това щеше да се установи тук, а не след това.
На стъпка 4 две извиквания са тръгнали с един отговор. Четенията не зависят едно от друго и харнесът ги е изпълнил едновременно.
На стъпка 6 се е наложило да се вземат два реда. Един ред return null; във файла не е уникален – това е същият случай от раздела за редактирането.
Стъпка 7 затваря цикъла. Без нея агентът би спрял на „изглежда правилно“. С нея – на „тестовете минаха“. Ако тестът беше паднал, изходът щеше да се върне на модела и цикълът щеше да продължи: да се прочете грешката, да се поправи, да се стартира отново.
Общо осем заявки към модела. И всяка следваща носеше в себе си всичко предишно: към осмата в заявката бяха двете търсения, трите прочетени файла, двете редакции и изходът от тестовете. Това е съдържанието на контекста, за който е следващият раздел.
Контекст: прозорец, свиване и цена
Контекстният прозорец е границата за обема на една заявка към модела. В него трябва да се събере всичко: системният промпт, инструкциите, целият разговор, всеки прочетен файл и изходът на всяка команда.
При сегашните модели прозорецът е милион токена. Това стига за часове работа и трудно се стига до границата. Но прозорецът все пак се пълни и тогава се задейства свиването (compaction): Claude Code моли модела да преразкаже разговора и заменя историята с този преразказ. Работата продължава, но с кратка версия на миналото.
Тук е важно да знаете какво свиването преживява и какво не.
| Преживява | Не преживява във вида си |
|---|---|
| системният промпт и стилът на изхода | дословните формулировки на ранните съобщения |
коренният CLAUDE.md и правилата без връзка с пътища – препрочитат се от диска | правилата с връзка с пътища и CLAUDE.md от подпапките – връщат се, когато агентът отново пипне подходящ файл |
| автоматичната памет – препрочита се от диска | съдържанието на прочетените по-рано файлове, освен на няколко последни |
| списъкът със скилове | уговорките, дадени само в чата |
| телата на неотдавна извиканите скилове, с ограничение по обем | |
| фоновите команди и субагенти – продължават да работят |
Практическият извод е прост. Всичко, което трябва да действа през цялата сесия, трябва да лежи във файл, а не в чата. Казаното в чата може да не оцелее след свиването; записаното в инструкциите на проекта се препрочита от диска.
Това се управлява с четири команди: /context показва с какво е зает прозорецът; /compact свива сега и може да му подскажете какво да се запази; /clear започва разговора начисто, старият остава на диска; /autocompact задава прага, при който свиването се включва само.
Сега за цената. Щом всяка заявка носи целия разговор, дългата сесия би била много скъпа. Спасява кешът на промпта: непроменената начална част на заявката сървърът я запомня и при повторение я смята приблизително десет пъти по-евтино. Докато работите без дълги паузи, кешът е топъл и разговорът излиза евтино. След пауза кешът изстива и следващата заявка се плаща изцяло. От тук идва съвет, който изглежда странен, докато не знаете механизма: несвързаните задачи е по-изгодно да се правят в различни сесии, а не в една безкрайна.
Сесии: къде се пази разговорът и как да се върнете назад
Сесията е един разговор. Харнесът го записва на диска в хода на работата, в обикновен текстов файл във формат JSONL: един ред – един запис в JSON.
Лежи в домашната папка, в каталог с името на проекта:
~/.claude/projects/D--PycharmProjects-My-Site-on-Astro/├── 4e5a5be5-….jsonl разговор: съобщения, извиквания на инструменти, резултати├── 4e5a5be5-…/│ ├── subagents/ разговорите на субагентите от тази сесия│ └── tool-results/ големи изходи на инструменти, които не са се събрали в заявката└── memory/ автоматична памет на проектаИмето на папката е пътят към проекта, в който всичко освен буквите и цифрите е заменено с тирета. Така D:\PycharmProjects\My_Site_on_Astro се превръща в D--PycharmProjects-My-Site-on-Astro.
Ето как изглежда един запис – вашето съобщение. Оставил съм главните полета и съм разбил реда, за да се чете по-лесно; във файла това е един ред:
{ "type": "user", "uuid": "0b6f2c1e-…", "parentUuid": "9d41a7f3-…", "sessionId": "4e5a5be5-…", "timestamp": "2026-11-19T08:55:12.431Z", "cwd": "D:\\projects\\demo", "gitBranch": "master", "version": "2.1.328", "message": { "role": "user", "content": "направи така, че сесията да живее едно денонощие" }}Полето parentUuid свързва записа с предишния. Благодарение на това разговорът не е просто списък, а дърво: когато се върнете назад и тръгнете по друг път, старият клон остава във файла, а новият расте от същата точка. Записът на отговора на модела е устроен по същия начин, само че в message има блокове: размисъл, текст, извиквания на инструменти, а до тях – сведения за модела и за разхода на токени.
Във файла има записи от различни типове: съобщения на потребителя и на асистента, снимки на файлове, смяна на режима, име на сесията. Форматът е вътрешен и между версиите се променя, но това е обикновен текст: може да се отвори и да се търси в него. И от това следва важното: разговорите лежат на диска некриптирани. Ако агентът е прочел файл с парола, паролата вече е и във файла на сесията.
Сесиите се пазят 30 дни, после сами се изтриват; срокът се променя с настройката cleanupPeriodDays. Всичко, което Claude Code знае за един проект, може да се изтрие с командата claude purge.
Какво може да се прави със сесиите:
- Да се продължат.
claude --continueотваря последната сесия в тази папка,claude --resumeпоказва списък. Вътре в сесията същото прави/resume. - Да се разклонят.
/branchкопира разговора в нова сесия от текущото място, оригиналът не се променя. Удобно е да опитате друг път. - Да се наименуват.
/renameили флагът--name: по име сесията после се намира по-лесно.
Връщане назад: чекпойнти
Преди всяка редакция на файл харнесът запазва предишната му версия. Тези копия лежат в ~/.claude/file-history/, по една папка за сесия. Всяко ваше съобщение създава контролна точка.
Командата /rewind (или Esc два пъти на празен ред) отваря списък с точки. За избраната може да се върне кодът, да се върне разговорът или и двете. Там има и „свий, започвайки оттук“: файловете не се пипат, а опашката на разговора се заменя с преразказ.
Връщането назад има граница, която трябва да помните. То знае само за редакциите, направени с инструментите Edit и Write. Онова, което е направила команда на обвивката, то не го връща: изтрит с rm файл, миграция на базата, git push, инсталиран пакет. Не се следят и редакциите на субагентите, нито вашите собствени редакции в редактора. Чекпойнтите са застраховка в рамките на сесията, а не заместител на git.
Папката на проекта: какво има в .claude
Сега за това с какво Claude Code се настройва за конкретен проект. Почти всичко живее в папката .claude в корена на хранилището и се комитва заедно с кода, за да се държи агентът еднакво при целия екип.
проект/├── CLAUDE.md инструкции на проекта, четат се във всяка сесия├── CLAUDE.local.md лични инструкции, не отиват в git├── .mcp.json MCP сървъри на проекта├── .worktreeinclude кои файлове извън git да се копират в работните копия└── .claude/ ├── settings.json настройки на екипа: разрешения, хукове, променливи ├── settings.local.json лични настройки, не отиват в git ├── rules/ правила, по един файл за тема ├── skills/<име>/SKILL.md скилове ├── agents/ описания на субагенти ├── commands/ команди в стария формат ├── output-styles/ стилове на изхода ├── workflows/ запазени сценарии с няколко агента ├── agent-memory/ памет на субагентите ├── hooks/ обикновено тук се държат скриптовете на хуковете └── worktrees/ отделни работни копия за паралелни сесииПо-нататък – за всяка част: какво е, кога се зарежда и с какво се различава от съседните.
Инструкции: CLAUDE.md
CLAUDE.md е текстов файл с онова, което агентът трябва да знае във всяка сесия: как се билдва проектът, как се стартират тестовете, какви неочевидни уговорки има тук. Първата версия помага да се създаде командата /init.
Файловете може да са няколко и те се наслагват. Редът на зареждане е такъв:
| Ниво | Къде лежи | За какво е |
|---|---|---|
| Организация | системна папка: C:\Program Files\ClaudeCode\, /etc/claude-code/, /Library/Application Support/ClaudeCode/ | правила на компанията, задава ги администраторът |
| Личен | ~/.claude/CLAUDE.md | вашите навици във всички проекти |
| Проект | CLAUDE.md в корена или .claude/CLAUDE.md | общи правила на проекта, в git |
| Личен в проекта | CLAUDE.local.md | вашите бележки за този проект, не в git |
Освен това се четат CLAUDE.md от всички папки над работната. А файловете от подпапките се зареждат при поискване – когато агентът чете или редактира нещо в тази подпапка. В монорепо това позволява всяка услуга да има свои инструкции и да не се зареждат всички наведнъж.
Вътре могат да се включват други файлове с ред @път/към/файл. Влагането е до четири нива.
За AGENTS.md. Това е общ формат за инструкции, който четат много агенти. Claude Code го чете само ако в проекта няма собствен CLAUDE.md. Поведението се променя в настройките: може да се четат и двата.
Главният съвет за този файл е да се държи кратък. Документацията посочва ориентир от двеста реда и причината не е в лимита, а в това, че дългите инструкции се спазват по-зле.
Правила: .claude/rules/
Правилата са същите инструкции, само че разложени по файлове, по един за тема. Правило без шапка се зарежда при старта, както CLAUDE.md.
По-интересно е правилото с шапка, където са посочени маски за пътища:
---paths: - "src/api/**/*.ts"---
# Правила за API
- Всеки ендпойнт валидира входа.- Грешките се връщат в общ формат.Такова правило попада в контекста само когато агентът прочете или пипне подходящ файл. Така правилата за базата данни не заемат място, докато работата е по оформлението.
Лични правила за всички проекти се слагат в ~/.claude/rules/.
Автоматична памет
Инструкциите и правилата ги пишете вие. Автоматичната памет агентът я пише сам. Това са бележки за онова, което е научил в хода на работата и което ще е полезно в следващите сесии: какво предпочитате, какво решение сте взели, къде е нужният панел.
Тя се пази не в проекта, а в домашната папка: ~/.claude/projects/<проект>/memory/. Вътре има индексен файл MEMORY.md и отделни файлове по теми. В началото на сесията в контекста попада само началото на индекса, първите двеста реда. Тематичните файлове агентът ги отваря, когато му трябват.
Индексът е просто списък с връзки, по един ред за бележка:
- [Тестове само през контейнер](tests-in-docker.md) – локалното стартиране на тестовете пада, нужна е базата от docker compose- [Панел за мониторинг](grafana-dashboard.md) – къде да се гледат закъсненията на API след публикуванеА самата бележка е файл с къса шапка и един факт:
---name: tests-in-dockerdescription: Интеграционните тестове да се стартират само в контейнер, локално падатmetadata: type: feedback---
Интеграционните тестове да се стартират с командата `docker compose run tests`.
**Защо:** тестовете се нуждаят от база с определена версия, локално я няма.**Как да се прилага:** преди стартиране на тестовете не опитвайте `npm test` директно.Типовете бележки са четири: за потребителя, за неговите забележки към работата, за проекта и връзки към външни ресурси. По описанието в шапката агентът решава дали да отвори файла.
Какво следва от това:
- Паметта е локална за машината и за вас. Колегата няма да я получи, на друг компютър я няма. Всичко, което трябва да знаят всички, е в правилата на проекта.
- Това са обикновени Markdown файлове. Може да се четат и редактират на ръка; с командата
/memory– да се прегледат и да се изключат. - Проектът се определя по git хранилището, затова при всички работни копия на едно хранилище паметта е обща.
- Чистенето по срок за съхранение не я пипа.
За да не се бъркат, ето с какво се различават трите вида „памет“:
| Кой пише | Къде лежи | Вижда ли го екипът | Кога е в контекста | |
|---|---|---|---|---|
CLAUDE.md и правила | вие | в хранилището | да | винаги или по маска за пътища |
| Автоматична памет | агентът | в домашната папка | не | индексът – винаги, темите – при поискване |
| История на сесията | харнесът | в домашната папка | не | само в тази сесия |
Скилове: знание при поискване
Скилът е папка с файл SKILL.md: инструкция как да се върши определена работа. Например как да се публикува релийз или как да се четат данни от аналитиката. До него могат да лежат помощни файлове и скриптове.
Ключовата идея е постепенното зареждане. В неактивно състояние от скила в контекста има само име и описание. Когато задачата отговаря на описанието, агентът извиква инструмента Skill и тялото на файла попада в контекста. Файловете до него се четат само ако има препратка към тях и са потрябвали. Затова справочник от хиляда реда във вид на скил почти нищо не струва, а във вид на правило би струвал във всяка сесия.
---name: releasedescription: Издаване на нова версия. Да се използва, когато поискат да се издаде релийз или да се вдигне версията.disable-model-invocation: trueallowed-tools: Bash(npm version *), Bash(git tag *)---
1. Да се провери, че работното дърво е чисто.2. Да се вдигне версията: `npm version $ARGUMENTS`.3. Да се билдне проектът и да се прекарат тестовете.Какво е важно тук:
descriptionе това, по което агентът решава дали скилът става. Описанието е по-важно от тялото: зле описан скил няма да бъде извикан.disable-model-invocation: trueзабранява на агента да стартира скила сам. Остава ръчното извикване с командата/release 1.4.0. Така се отбелязват процедурите с последствия.$ARGUMENTSсе заменя с онова, което сте написали след името на командата.allowed-toolsпредварително разрешава изброените инструменти за времето на работата на скила.
Скилът може да се стартира и в отделен контекст (context: fork): тогава той се изпълнява като субагент и връща само резултата.
Скиловете и слеш командите са едно и също. Всеки скил се извиква като /име. Старият формат, файловете в .claude/commands/, все още работи. Скиловете са лични (~/.claude/skills/), проектни, от плъгини и вградени: /code-review, /simplify, /doctor, /loop, /run и други.
За списъка със скилове в контекста е отделено малко място – около един процент от прозореца. Когато скиловете са много, при рядко използваните остава само името. Колко струва всеки, може да се види в /skills.
Субагенти
Субагентът е отделен екземпляр на агента със свой чист контекст. Главният агент му дава задача, субагентът работи в собствен цикъл и връща един краен отчет.
За какво е нужно. Представете си задачата „разбери как е устроена авторизацията“. За да се отговори, трябва да се прочетат двайсет файла. Ако ги чете главният агент, и двайсетте остават завинаги в неговия контекст. Ако ги чете субагентът, в главния контекст се връща една страница изводи, а двайсетте файла изчезват заедно със субагента.
Това има цена и за нея често забравят. Субагентът не е виждал вашия разговор. Той знае само онова, което главният агент му е написал в заданието. И главният агент вижда само крайния отчет, а не как субагентът е стигнал до него. При всяко предаване се губят детайли. Затова субагентите са добри за разузнаване и за независими парчета работа и лоши за задачи, където е важен целият натрупан контекст.
Вградените субагенти са няколко:
| Име | Какво прави |
|---|---|
Explore | само четене: бързо търсене в кодовата база |
Plan | само четене: подготвя план за реализация |
general-purpose | всички инструменти, за многостъпкови задачи |
claude-code-guide | отговаря на въпроси за самия Claude Code |
Свои се описват с файлове в .claude/agents/ или ~/.claude/agents/:
---name: test-runnerdescription: Стартира тестовете и разбира падненията. Да се използва след промени в кода.tools: Read, Grep, Glob, Bashmodel: haiku---
Стартирай тестовете, намери причината за всяко падане и върни къс списък:тест, причина, файл и ред.Тялото на файла е системният промпт на субагента. В шапката се задава кои инструменти са му достъпни, на какъв модел работи, в какъв режим на разрешения. Простата механична работа е изгодно да се дава на евтин модел.
Полезни възможности:
- Фон. Субагентът може да работи на фон, докато главният агент е зает с друго; резултатът идва с известие.
- Изолация. С
isolation: worktreeсубагентът получава собствено копие на хранилището и не пречи на редакциите в основното. - Форк. Обикновеният субагент започва начисто. Форкът наследява целия разговор; стартира го
/subtask. - Собствена памет. С полето
memoryсубагентът получава папка с бележки, която преживява сесиите. - Влагане. Субагентът може да стартира свой субагент, до три нива навътре.
И за разхода. Пет субагента паралелно са приблизително пет сесии по цена. Няма смисъл да ги стартирате заради задача от три файла.
Хукове
Всичко изброено по-горе е текст, който моделът чете и обикновено изпълнява. Хукът е друго: ваш код, който харнесът стартира сам в определен момент, каквото и да е решил моделът.
Моментите, на които може да се закачи хук, са над тридесет: старт на сесията, изпращане на съобщение, преди извикване на инструмент и след него, заявка за разрешение, край на хода, свиване на контекста и така нататък. Хукът получава на входа JSON с описание на събитието и може не само да направи нещо, но и да повлияе на хода: да забрани извикването на инструмент, да добави текст в контекста, да върне агента към работата.
{ "hooks": { "PostToolUse": [ { "matcher": "Edit|Write", "hooks": [{ "type": "command", "command": "npm run lint" }] } ] }}Този хук стартира линтера след всяка редакция на файл. Моделът не е бил молен за това – прави го харнесът.
Правилото за избор е такова: онова, което трябва да се случва винаги, се прави с хук, а не с ред в инструкциите. Форматиране след редакция, забрана да се пипа определена папка, звук при края на хода, запис в журнал. Подробно, с всички събития и работни примери – в статията за хуковете.
MCP: външни инструменти
Вградените инструменти стигат за работа с файлове и с терминала. Но на агента понякога му трябва и друго: да погледне в тракера на задачите, в базата данни, в документацията на библиотека. За целта има MCP (Model Context Protocol) – стандарт, по който външна програма-сървър обявява своите инструменти, а агентът ги извиква. Как е устроен самият протокол, писах в отделна статия.
За Claude Code MCP сървърът е просто още един набор от инструменти. Свързва се с команда или с файл:
{ "mcpServers": { "docs": { "type": "http", "url": "https://mcp.example.com/mcp" }, "local-db": { "command": "npx", "args": ["-y", "example-db-mcp"], "env": { "DB_URL": "${DB_URL}" } } }}Първият сървър е отдалечен, до него агентът стига по HTTP. Вторият е локален: Claude Code сам го стартира като процес и общува с него през стандартния вход и изход.
Същото се прави с команди, без да се редактира файлът на ръка:
claude mcp add --transport http docs https://mcp.example.com/mcpclaude mcp add local-db -e DB_URL=postgres://localhost/app -- npx -y example-db-mcpclaude mcp add --scope project --transport http docs https://mcp.example.com/mcpПървата команда добавя отдалечен сървър. Втората – локален: всичко след двете тирета е командата за стартирането му. Третата се различава по флага --scope: той решава на кого ще е видим сървърът.
Инструментите на сървъра получават имена от вида mcp__<сървър>__<инструмент>, например mcp__docs__search. Под тези имена те фигурират в правилата за разрешения и в хуковете.
Сървърът може да се свърже на три нива и от нивото зависи къде се пази записът:
| Ниво | На кого е видим | Къде е записан |
|---|---|---|
| local (по подразбиране) | на вас, в този проект | ~/.claude.json, в раздела на проекта |
| project | на целия екип | .mcp.json в корена на хранилището |
| user | на вас, във всички проекти | ~/.claude.json |
Сървърите от .mcp.json изискват еднократно потвърждение: чуждо хранилище не бива мълчаливо да стартира програми на вашата машина.
Важен детайл за контекста. Преди всеки сървър веднага излагаше в контекста пълните описания на всичките си инструменти и пет сървъра можеха да изядат десетки хиляди токена. Сега описанията са отложени: в контекста има само имена. Когато инструментът е потрябвал, агентът извиква ToolSearch и получава пълната му схема. Затова много свързани сървъри вече не са проблем.
И още нещо: ако сте влезли през акаунт в claude.ai, конекторите, свързани там (поща, календар, диск), са достъпни и в Claude Code.
Плъгини, маркетплейси и модове
Плъгинът е опаковка. В една папка се събират скилове, субагенти, хукове, MCP сървъри, стилове на изхода, теми, изпълними файлове и всичко това се инсталира с една команда. Така се споделят настройки между проекти и екипи.
Източникът на плъгини се нарича маркетплейс. Това е git хранилище или адрес с файл-каталог. Официалният маркетплейс на Anthropic се свързва сам при първото стартиране. Управлението е с командата /plugin: да се видят наличните, да се инсталират, да се включат, да се изключат.
Два вида плъгини си струва да се отделят.
Плъгини за езикови сървъри. Те дават на агента инструмента LSP, за който ставаше дума в раздела за търсенето. Има готови за около петнайсет езика, от TypeScript и Python до Kotlin и Rust. Самият езиков сървър трябва да е инсталиран в системата.
Модове. Обикновеният плъгин добавя на агента знания и инструменти. Модът променя самия Claude Code: кодът му работи вътре в програмата. Модът може да нарисува панел до чата или лента над полето за въвеждане, да добави команда, която се изпълнява мигновено, без обръщане към модела, да се намеси в извикването на инструмент. Модовете се появиха във версия 2.1.287. Може да напишете свой, като просто помолите агента.
Към модовете трябва да се отнасяте като към всяка програма, която стартирате: кодът на мода работи с вашите права и извън пясъчника. Ако след инсталирането нещо се е счупило, claude --safe-mode ще стартира сесия без всички настройки, плъгини и хукове.
Стилове на изхода, лента на състоянието, клавиши
Три малки настройки на интерфейса.
Стилът на изхода променя маниера на отговорите. Вградените са: обикновен, кратък, обясняващ (добавя пояснения защо е направено така) и обучаващ (оставя ви парчета за самостоятелна работа). Свои се слагат като файлове в output-styles/.
Лентата на състоянието е долният ред на интерфейса. Рисува я ваш скрипт: харнесът му предава JSON с данни за сесията, а онова, което скриптът отпечата, се появява на екрана. Там извеждат клона на git, модела, запълването на контекста, разхода на лимита.
Клавишите се преназначават във файла ~/.claude/keybindings.json.
Настройки: къде лежат и кои са по-главни
Настройките се пазят във файлове settings.json. Те са няколко и една и съща настройка може да е зададена в няколко от тях. Побеждава нивото с по-висок приоритет.
| Приоритет | Ниво | Файл |
|---|---|---|
| 1, най-висок | Организация | managed-settings.json в системната папка, политика на ОС или настройки от сървър |
| 2 | Стартиране | флагът --settings |
| 3 | Лични в проекта | .claude/settings.local.json |
| 4 | Проект | .claude/settings.json |
| 5 | Лични | ~/.claude/settings.json |
Списъците не се припокриват, а се събират. Правилата за разрешения от личния файл и от файла на проекта действат заедно.
Има и още един файл, който постоянно се бърка с настройките: ~/.claude.json. Той лежи не в папката .claude, а до нея, в домашния каталог. Това не са настройки, а състояние: в кой акаунт сте влезли, на кои папки имате доверие, личните MCP сървъри, броячите на подсказките, кешове. Claude Code пише в него сам. Обикновено няма нужда да го пипате на ръка.
Третият механизъм са променливите на средата. С тях се задават ключът за API, доставчикът, моделът, таймаутите. Могат да се зададат в обвивката или в блока env на файла с настройки.
Да проверите какво наистина се е заредило, помагат две команди: /status показва източниците на настройките, /doctor намира повредените файлове и противоречията. Пълният списък с ключове с примери е в справочника.
Какво има на диска извън проекта
Проектът е само част от картината. По-голямата част от данните на Claude Code живее в домашната папка на потребителя. На Windows това е C:\Users\<име>\.claude, на macOS и Linux – ~/.claude.
Ето какво има там. Част от папките се появяват едва когато започнете да ползвате съответната възможност.
~/.claude/├── settings.json лични настройки├── CLAUDE.md лични инструкции за всички проекти├── keybindings.json свои клавишни комбинации├── rules/ skills/ agents/ commands/ output-styles/ workflows/ themes/│ лични правила, скилове, субагенти и други├── .credentials.json данни за вход в акаунта├── history.jsonl история на въведените от вас съобщения├── projects/ разговори и автоматична памет, по папка за проект├── file-history/ копия на файлове за връщане назад├── sessions/ по малък файл за всяка стартирана сесия├── session-env/ среда на сесиите├── shell-snapshots/ снимки на настройките на обвивката├── paste-cache/ големи вмъквания от клипборда├── plans/ планове от режима на планиране├── tasks/ списъци със задачи├── plugins/ инсталирани плъгини и маркетплейси├── daemon/ jobs/ състояние на фоновите сесии├── ide/ връзка със стартираните IDE├── chrome/ мост към разширението в браузъра├── debug/ дебъг логове├── backups/ копия на файла ~/.claude.json├── cache/ каталог на моделите, списък на промените├── agent-memory/ памет на личните субагенти└── teams/ пощенски кутии на екипите от агентиЩе разгледаме онова, което е важно да се разбира.
projects/ е най-голямата и най-ценната папка. Тук са всичките ви разговори и цялата автоматична памет. При мен в нея има няколко десетки подпапки, по една за всеки проект, в който съм стартирал Claude Code поне веднъж. Ако пренасяте работата на друг компютър, копира се тя.
.credentials.json са данните за вход. На Windows и Linux това е файл, защитен с правата за достъп на профила на потребителя. На macOS данните за вход лежат в системната връзка с ключове, а файлът се ползва като резервен вариант. Този файл не бива да се комитва, да се препраща и да се показва.
history.jsonl е онова, което сте писали в полето за въвеждане. От него работят стрелката нагоре и търсенето с Ctrl+R. По срок за съхранение не се изтрива.
sessions/ са служебните файлове на работещите сесии: номер на процеса, работна папка, име, статус. По тях сесиите се намират една друга и по тях Claude Code разбира, че сесията е паднала.
file-history/ са копията на файловете преди редакциите. Версиите се наричат по хеша на пътя с номер: първа редакция, втора, трета.
shell-snapshots/ са снимките на алиасите и функциите на вашата обвивка. Заради тях командите на агента се държат като вашите.
ide/ са файловете-ключалки с порта, на който слуша разширението във VS Code или JetBrains. Чрез тях терминалната сесия намира отворения редактор.
Чистенето работи така: разговорите, копията на файлове, плановете, логовете и вмъкванията се изтриват, когато станат по-стари от срока за съхранение, по подразбиране 30 дни. Автоматичната памет, историята на въвеждането и настройките не се изтриват.
Сега онова, което лежи извън ~/.claude:
| Какво | Къде е на Windows | Къде е на macOS и Linux |
|---|---|---|
| Състояние и лични MCP сървъри | C:\Users\<име>\.claude.json | ~/.claude.json |
| Самата програма | C:\Users\<име>\.local\bin\claude.exe | ~/.local/bin/claude |
| Временни файлове на сесията | %TEMP%\claude\<проект>\<сесия>\ | временната папка на системата |
| Настройки на организацията | C:\Program Files\ClaudeCode\ | /etc/claude-code/, /Library/Application Support/ClaudeCode/ |
| Мост към браузъра | %APPDATA%\Claude Code\ChromeNativeHost | папката с настройки на браузъра |
| Кеш | %LOCALAPPDATA%\claude-cli-nodejs\ | папката с кеша на потребителя |
Във временната папка всяка сесия има своя „чернова“ директория. Там агентът слага еднократните скриптове и междинните файлове, за да не замърсява проекта.
Всичко, което се пази в ~/.claude, може да се премести на друго място с променливата CLAUDE_CONFIG_DIR. Това е и начинът да държите на една машина два акаунта: всеки има своя папка с конфигурация.
Разрешения: какво може агентът без питане
Досега говорехме за това какво агентът умее. Сега – за това какво му е позволено. Това е отделен слой и работи в харнеса: моделът може да поиска каквото и да е, но харнесът ще изпълни само позволеното.
Режими
Режимът определя поведението по подразбиране. Превключва се с Shift+Tab направо по време на работа.
| Режим | Какво прави без въпроси |
|---|---|
Ръчен (default) | само чете; за редакции и команди пита |
acceptEdits | плюс редактира файлове и изпълнява прости файлови команди в работната папка |
plan | чете и проучва, пише план; изходния код не го пипа |
auto | всичко, но всяко действие се проверява от фонов класификатор |
dontAsk | онова, което е позволено от правилата; всичко останало мълчаливо отхвърля |
bypassPermissions | всичко без въпроси; правилата за забрана остават в сила |
Последният режим се включва с флага --dangerously-skip-permissions и името е честно: той е предназначен за изолирани среди – контейнер или виртуална машина без достъп до нещо ценно.
Правила
Върху режима действат правила от три вида: да се позволи, да се попита, да се забрани.
{ "permissions": { "allow": ["Bash(npm run *)", "Edit(src/**)"], "ask": ["Bash(git push *)"], "deny": ["Read(./.env)", "Read(./secrets/**)"] }}Правилото е име на инструмент и уточнение в скоби. За командите това е началото на командата със звездичка, за файловете – маска за път, за уеба – домейн.
Примери за правила и какво означават:
| Правило | Какво покрива |
|---|---|
Bash(npm run build) | точно тази команда |
Bash(npm run *) | всяка команда, започваща с npm run |
Bash(git log *) | git log с всякакви аргументи, но не git push |
Edit(src/**) | редакция на всякакви файлове в src |
Read(./.env) | четене на файла .env в корена на проекта |
Read(~/.ssh/**) | четене на каквото и да е в папката с ключовете |
WebFetch(domain:docs.example.com) | зареждане на страници от този домейн |
mcp__docs__* | всички инструменти на MCP сървъра docs |
Agent(Explore) | стартиране на субагента Explore |
Bash | инструмента целия |
Как работи това на жив пример. Агентът иска да изпълни npm run test && git push origin main. Харнесът разделя командата на две части. Първата отговаря на разрешението Bash(npm run *). Втората отговаря на правилото „попитай“ Bash(git push *). Резултатът: въпрос към вас и във въпроса се вижда цялата команда.
Когато в диалога изберете „повече не питай“, харнесът сам дописва правило в личните настройки на проекта, .claude/settings.local.json. Да видите и да изчистите натрупаното може с командата /permissions.
Правилата се проверяват по ред: първо забраните, после „попитай“, после разрешенията. Побеждава първото съвпадение, затова забраната винаги е по-силна от разрешението. Забраната за четене на файл важи и за търсенето: такъв файл изпада от резултатите.
Няколко неща, които правят правилата по-надеждни, отколкото изглежда:
- Съставната команда се разбира на части.
npm test && rm -rf buildсе проверява като две команди и трябва да са разрешени и двете. - Обвивките като
timeoutилиnohupсе отхвърлят преди проверката. - Пренасочването на изхода във файл се проверява като редакция на този файл.
И едно нещо, заради което на правилата за команди не може да се разчита като на стена: едно и също може да се изпълни по много начини. Забраната Bash(curl *) няма да хване /usr/bin/curl или скрипт на Python, който прави същата заявка. Забраните за команди пазят от случайности, а не от целенасочено заобикаляне. Истинската граница я поставя пясъчникът.
Доверие към папката и защитени пътища
При първото стартиране в нова папка Claude Code пита дали ѝ имате доверие. Това не е формалност. Файловете на проекта могат да съдържат хукове и MCP сървъри, тоест код, който ще се изпълни на вашата машина. Докато не потвърдите, разрешаващите правила от проекта не се прилагат. Чуждо хранилище е добре първо да се огледа с очи.
Освен това има защитени пътища, запис в които изисква потвърждение дори в режима на автоматични редакции: папките .git, .vscode, .idea, .claude, файловете с настройки на обвивката, .mcp.json. С промяната им може да се накара да се изпълни произволен код, затова харнесът ги пази отделно.
Авторежим
Ръчният режим е безопасен, но уморителен: на стотното потвърждение човек спира да чете какво потвърждава. Авторежимът решава това иначе. Въпроси няма, но всяко действие, което не е позволено изрично от правилата, се проверява от отделен модел-класификатор.
Какво вижда той: вашите съобщения, извикванията на инструменти и инструкциите на проекта. Резултатите от инструментите не му се показват – за да не може текст от прочетен файл или уеб страница да убеди и него.
Какво блокира по подразбиране: да свали от мрежата скрипт и веднага да го изпълни, да изпрати тайни навън, да пусне в продукция, да изтрие данни в облака, да раздаде права за достъп, да направи git push --force или git reset --hard. Какво пропуска: работа с файлове в проекта, инсталиране на обявени зависимости, заявки за четене, обикновен push в клон.
Ако класификаторът е блокирал три действия подред, авторежимът се приспира и се връщат обикновените въпроси.
Свои правила за класификатора се пишат с обикновен текст в личните настройки: кои хранилища и услуги да се смятат за свои, какво е забранено винаги.
{ "autoMode": { "environment": [ "$defaults", "Хранилищата на организацията example-org в GitHub са свои", "Бакетът example-staging е тестов, в него може да се пише" ], "hard_deny": [ "$defaults", "Всякакви промени в продукционната база данни" ] }}Това не са шаблони, а изречения на човешки език: чете ги моделът-класификатор. Редът "$defaults" запазва вградените правила, без него вашият списък би ги заместил. От настройките на проекта този блок не се чете – иначе чуждо хранилище би могло да си разреши каквото си поиска.
И най-важното, което трябва да се разбира: авторежимът спестява потвържденията, но самата Anthropic не го смята за граница на сигурността. Това е внимателен наблюдател, а не стена.
Пясъчник и изолация
Разрешенията решават какво агентът ще поиска да направи. Изолацията решава какво ще може да направи, дори ако нещо тръгне накриво. Вариантите са няколко, от лекия към строгия.
Пясъчник за командите
Пясъчникът е ограничение на ниво операционна система за командите, които стартира агентът. Командата и всички процеси, които тя породи, получават орязан достъп:
- Запис – само в работната папка и във временната директория.
- Мрежа – директен изход няма. Целият трафик минава през локален прокси, който пропуска само разрешените домейни.
- Четене – по подразбиране почти целият диск. Папките с ключове трябва да се затворят изрично.
{ "sandbox": { "enabled": true, "network": { "allowedDomains": ["registry.npmjs.org", "*.githubusercontent.com"] }, "filesystem": { "denyRead": ["~/.ssh", "~/.aws"] } }}На macOS пясъчникът е построен върху системния механизъм Seatbelt, на Linux и в WSL2 – върху bubblewrap. На Windows без WSL пясъчник няма: командите се изпълняват както обикновено. Ако ви трябва на Windows, стартирайте Claude Code вътре в WSL2.
По подразбиране пясъчникът е изключен; включва се с командата /sandbox. Има приятен страничен ефект: щом командата не може да повреди нищо извън проекта, може да се изпълнява без въпрос. Потвържденията стават осезаемо по-малко.
Какво пясъчникът не покрива, и това трябва да се знае. Той обвива само командите на обвивката. Инструментите за четене и редактиране на файлове работят извън него и се подчиняват на правилата за разрешения. Локалните MCP сървъри, хуковете и модовете също се стартират извън пясъчника, с вашите права.
Отделни работни копия
Втората задача на изолацията е паралелните сесии да не си пречат. Ако два агента редактират едни и същи файлове в една папка, излиза каша.
Решението е git worktree. Това е щатна възможност на git: втора работна папка на същото хранилище на свой клон. Историята е обща, файловете са отделни.
claude --worktree feature-authКомандата създава работно копие в .claude/worktrees/feature-auth/ на нов клон и стартира сесия в него. Фоновите сесии и субагентите с изолация правят същото автоматично. Копие без промени се изтрива при излизане само.
Една практическа подробност: файловете, които ги няма в git, не попадат в новото копие. Ако на проекта му трябва .env, изброете го във файла .worktreeinclude и той ще бъде копиран.
Важно е да не се бърка: worktree пази вашите файлове от другите агенти, а не машината от агента. Това е изолация на работата, а не сигурност.
Контейнер и виртуална машина
Най-надеждната изолация е да стартирате агента там, където няма какво да се повреди.
Dev контейнер. Anthropic има готова конфигурация: контейнер с Claude Code и мрежова защитна стена (firewall), която пропуска само нужните адреси. Вътре може да се включи режимът без въпроси, защото на агента му е достъпен само монтираният проект.
Виртуална машина. Същото, но границата е още по-твърда. За този вариант подробно по-долу, в раздела за отдалечената работа.
Облачна сесия. Anthropic стартира агента на своя виртуална машина. Вашият компютър изобщо не участва.
Обобщение, за да избирате:
| Начин | От какво пази | Какво не закрива |
|---|---|---|
| Правила за разрешения | от случайни действия | заобикалят се с друг начин да се направи същото |
| Авторежим | от явно опасни действия без въпроси | не е граница на сигурността |
| Пясъчник | командите няма да излязат извън проекта и разрешените домейни | инструментите за файлове, MCP, хуковете; няма го на Windows без WSL |
| Worktree | сесиите не си пречат | не пази машината |
| Контейнер, ВМ | агентът не вижда вашата система | онова, което сами сте монтирали там, и ключовете, които сте дали |
Модели, усилие и размисъл
Харнесът е един, а моделите зад него са няколко и всеки има свои регулатори.
Моделът се избира с командата /model или с флага --model. Обикновено се пише не пълният идентификатор, а късото име на семейството: fable, opus, sonnet, haiku. Зад късото име винаги стои най-пресният модел на семейството. По-старшите модели са по-умни и по-скъпи, по-младшите са по-бързи и по-евтини. Има и съставен вариант opusplan: старшият модел планира, средният изпълнява.
Усилието (effort) е това колко моделът мисли и проверява, преди да отговори. Нивата са пет: low, medium, high, xhigh, max. Ниското става за дребни ясни редакции, високото – когато е важна проверката, максималното – за наистина трудни задачи, със спадаща отдача. Задава се с командата /effort. Усилието влияе и на скоростта, и на разхода: на max същата задача може да струва пъти повече, отколкото на medium.
Размисълът (thinking) са разсъжденията на модела преди отговора, които виждате свити. При сегашните модели той е адаптивен: моделът сам решава къде да помисли по-дълго. Думата ultrathink в съобщението вдига усилието само за този ход.
Бързият режим (/fast) е същият модел, но отговорът идва приблизително два и половина пъти по-бързо и струва повече. Само за старшите модели.
Съветникът (/advisor) е втори, по-силен модел, с когото основният се консултира в ключови моменти от задачата. Експериментална възможност.
Резервният модел: ако основният е претоварен, сесията ще продължи на резервния. Задава се с флага --fallback-model.
Отделно стои ultracode. Това не е ниво на усилие, а режим на работа: за всяка по-съществена задача агентът сам пише сценарий с няколко субагента и го стартира. За сценариите – в раздела за взаимодействието между сесиите. Разходът на токени в този режим е осезаемо по-висок.
Същият регулатор има и при частите на системата. На субагента и на скила може да се зададе свой модел и свое усилие в шапката на файла. Така разузнаването се дава на бърз евтин модел, а главният разговор се оставя на силния.
Къде се стартира Claude Code
Харнесът е един и същ двигател с няколко лицеви страни.
| Къде | Какво е | Особености |
|---|---|---|
| Терминал | програмата claude | пълен набор от възможности, оттук е започнало всичко |
| VS Code | разширение | редакциите се показват в прозореца на редактора, агентът вижда избрания код |
| JetBrains | плъгин | преглед на редакциите в IDE, сесия, обща с терминала |
| Приложение Desktop | програма за macOS и Windows | няколко сесии една до друга, преглед на diff, вграден браузър, свързване по SSH |
| Уеб | claude.ai/code | облачни сесии, работят без вашия компютър |
| Телефон | приложението Claude | облачни сесии и управление на сесиите на компютъра |
| Slack | @Claude в канал | задача от кореспонденцията отива в облачна сесия |
| CI | GitHub Actions, GitLab CI/CD | стартиране по събитие, без човек |
Локалните повърхности си делят всичко: настройките, инструкциите на проекта, MCP сървърите, историята на сесиите. Разговор, започнат в терминала, може да се отвори в приложението с командата /desktop. Облачните сесии живеят отделно: имат своя среда и до файловете на вашия диск не стигат.
Инсталиране. Основният начин е собственият инсталатор: една команда за macOS и Linux, една за PowerShell. Има пакети за Homebrew, WinGet и npm. Поддържат се macOS 13 и по-нови, Windows 10 и по-нови, разпространените дистрибуции на Linux; трябват поне 4 ГБ памет. Инсталираната така програма се обновява сама, на фон. Каналът за обновления се избира: най-свежият или стабилният, със закъснение около седмица.
На Windows има два варианта. Стартиране направо: всичко работи, освен пясъчника; желателно е да се инсталира Git for Windows, за да има агентът Bash. Стартиране в WSL2: това е пълноценен Linux с всички възможности, включително пясъчника, но без интеграция с браузъра Chrome.
Браузър: какви има варианти
На агента често му трябва да погледне резултата от работата си: да отвори страница, да натисне бутон, да прочете грешка в конзолата. Начините са много и да се избира между тях е по-лесно по три въпроса.
Чий е този браузър. Вашият истински, с всички входове в пощата и в работните услуги, или отделен чист, където агентът до нищо ваше няма да стигне.
Как агентът вижда страницата. Тук има три начина и от тях зависят точността и разходът на токени:
- Екранна снимка. Картинка, каквато я вижда човекът. Универсално е, но е скъпо в токени и по бутона се удря по координати.
- Дърво на достъпността. Това е структурно описание на страницата, което ползват екранните четци: „бутон «Вход», поле «Имейл», връзка «Забравена парола»“. Агентът го получава като текст, където всеки елемент има къс номер, и натиска по номер, а не по координати. По-евтино е и по-точно от картинката.
- Вътрешностите на браузъра. Конзола, мрежови заявки, стилове, замервания на скоростта – онова, което виждате в инструментите за разработчици.
Трябва ли прозорец. На лаптопа прозорец има. В контейнер, на сървър и в CI няма и браузърът трябва да работи в режим без интерфейс (headless).
Обобщение на всички варианти:
| Вариант | Чий е браузърът | Как вижда страницата | Без прозорец | Кой го прави |
|---|---|---|---|---|
WebFetch, WebSearch | никакъв | текст в преразказ | да | вграден |
| Claude in Chrome | вашият, с входове | страница, снимки, конзола, мрежа | не | Anthropic |
| Вграденият браузър на Desktop | чист, в приложението | страница и снимки | не | Anthropic |
| Playwright MCP | свой профил или вашият браузър | дърво на достъпността, по желание снимки | да | Microsoft |
| Playwright CLI | по подразбиране чист | дърво на достъпността, при поискване | да, по подразбиране | Microsoft |
| Chrome DevTools MCP | свой или вече стартиран Chrome | дърво, снимки, конзола, мрежа, замервания на скоростта | да | екипът на Chrome DevTools |
| Firefox DevTools MCP | отделен профил на Firefox | дърво и снимки | да | Mozilla |
| Свой скрипт с Playwright или Puppeteer | всякакъв | каквото напишете в скрипта | да | вие и агентът |
| Облачен браузър | на сървърите на услугата | зависи от услугата | да | външни платени услуги |
| Управление на компютъра | всякакъв, като прозорец на екрана | екранна снимка | не | Anthropic |
Сега по ред.
Вградени инструменти
WebFetch и WebSearch не са браузър. Те стават, за да се прочете публична страница от документация, и не стават за всичко, където трябва вход, JavaScript или натискане на бутони. Описани са по-горе, в раздела за инструментите.
Claude in Chrome: вашият истински браузър
Това е разширение за Chrome и Edge плюс мост към Claude Code. Включва се с флага claude --chrome или с командата /chrome. Агентът работи в истинския прозорец на вашия браузър, в нов раздел, и вижда сайтовете така, както ги виждате вие: с вашите входове в пощата, контролните табла, тракерите.
Какво умее: да минава по страници, да натиска и да попълва форми, да чете текста на страницата, конзолата и мрежовите заявки, да прави екранни снимки, да записва GIF с хода на действията.
Това е и сила, и риск. Силата е в това, че агентът може да направи нещо в услуга, където имате вече отворена сесия, без да получава пароли. Рискът е в същото. Затова достъпът се дава в разширението за всеки сайт отделно, а при вход в акаунт и при капча агентът спира и ви чака.
Как е устроена връзката. Разширението не може само да общува с програма на компютъра, затова Claude Code при първото включване регистрира в системата малък посредник (native messaging host). През него разширението и терминалната сесия си разменят команди. При мен той лежи в %APPDATA%\Claude Code\ChromeNativeHost.
Ограничения: нужни са абонамент и вход през акаунт, с ключ за API не работи; в WSL не работи; режим без прозорец няма; отвореният на страницата системен прозорец с въпрос блокира управлението.
Вграденият браузър на приложението Desktop
В приложението Desktop има панел на браузъра до чата. Профилът му е свой, чист, вашите входове там ги няма. Показва стартираното приложение на проекта и външни сайтове и агентът може да действа в него. Действията във външни сайтове изискват потвърждение.
За разработка това е по-спокойно от разширението: агентът вижда вашия сайт на локалния сървър, а до пощата ви няма достъп.
Playwright MCP
Playwright е библиотека на Microsoft за автоматизация на браузъри; с нея се пишат сквозни тестове. Има MCP сървър, който дава на агента инструменти за управление на браузъра: да отвори адрес, да натисне, да въведе текст, да направи снимка.
Свързва се с една команда:
claude mcp add playwright npx @playwright/mcp@latestИли с плъгин от официалния маркетплейс, който прави същото:
claude plugin install playwright@claude-plugins-officialГлавната особеност: по подразбиране агентът работи с дървото на достъпността, а не с картинка. Той иска снимка на страницата и получава текст приблизително от такъв вид:
- heading "Вход" [level=1]- textbox "Имейл" [ref=e12]- textbox "Парола" [ref=e13]- button "Вход" [ref=e15]- link "Забравена парола?" [ref=e16]Нататък той казва „натисни e15“ и сървърът натиска именно този бутон. Моделът не трябва да налучква координати и токените отиват осезаемо по-малко, отколкото за картинка. Режим с координати също има: включва се с флага --caps=vision и трябва там, където дървото не помага, например на платно с графика.
Какво се настройва с флаговете:
| Флаг | Какво прави |
|---|---|
--browser | кой браузър: Chrome, Edge, Firefox или WebKit |
--headless | да работи без прозорец; по подразбиране прозорецът се показва |
--isolated | профил само в паметта, след затваряне нищо не остава |
--user-data-dir | собствен път до профила |
--storage-state | да зареди запазените бисквитки (cookies) в изолирана сесия |
--extension | да се свърже с вашия вече отворен Chrome или Edge през разширението на Playwright |
--cdp-endpoint | да се свърже с браузър, стартиран с порт за дебъгване |
За профила е добре да разберете едно нещо. По подразбиране той е постоянен: сървърът създава собствена папка за профил и пази в нея входовете между стартиранията. Това не е вашият личен профил, но ако веднъж сте влезли в услуга в този прозорец, входът ще се запази. За тестове, където е нужна чистота, се слага --isolated.
Самите автори предупреждават за две неща. Сървърът не е граница на сигурността: списъците с разрешени адреси не покриват пренасочванията. И сред инструментите има изпълнение на произволен код в браузъра, което е равносилно на пълен достъп до страницата.
Playwright CLI
Същият Playwright има и втори начин, направен специално за агенти в терминала: обикновена програма за командния ред вместо MCP сървър.
npm install -g @playwright/cli@latestplaywright-cli install --skillsВтората команда инсталира скилове за Claude Code: от тях агентът научава какви команди има и как да ги използва. Нататък той просто извиква програмата през Bash:
playwright-cli open https://example.complaywright-cli snapshot --depth=3playwright-cli click e15В какво е разликата с MCP сървъра. MCP сървърът връща дървото на страницата след всяко действие и то се натрупва в контекста. Програмата за командния ред печата само онова, което е поискано: снимка с нужната дълбочина, резултат от търсенето на елемент. Авторите на Playwright сами пишат, че за агенти-програмисти такъв път е по-икономичен, а MCP сървърът е по-добър там, където трябва дълго да се изследва страница със запазване на състоянието.
По подразбиране браузърът тук се стартира без прозорец и с чист профил в паметта; прозорецът се включва с флага --headed, запазването на профила – с флага --persistent.
Chrome DevTools MCP
Този сървър го прави екипът на инструментите за разработчици на Chrome. Да натиска и да въвежда текст също умее, но смисълът му е друг: той отваря на агента онова, което виждате в панела за разработчици.
- Скорост. Да запише трейс на зареждането на страницата и да разбере какво я забавя.
- Мрежа. Списък със заявки, хедъри и тела на отговорите.
- Конзола. Съобщения и грешки със стек, съотнесен към изходния код.
- Стилове. Кои CSS правила наистина са приложени към елемента.
- Одит. Проверка с Lighthouse.
- Памет. Снимки на heap за търсене на изтичания.
Инсталира се с плъгин:
claude plugin marketplace add ChromeDevTools/chrome-devtools-mcpclaude plugin install chrome-devtools-mcp@chrome-devtools-pluginsТой може да стартира собствен Chrome, а може да се свърже с вече работещ. За целта Chrome се стартира с порт за дебъгване и отделна папка за профил, а на сървъра се предава адресът:
chrome --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-debugnpx -y chrome-devtools-mcp@latest --browser-url http://127.0.0.1:9222Изборът между него и Playwright е прост. „Мини през формата и провери дали поръчката се създава“ – това е Playwright. „Страницата се зарежда четири секунди, разбери защо“ – това е Chrome DevTools. Работи само с Chrome. И по подразбиране изпраща на Google статистика за използването; изключва се с флага --no-usage-statistics.
Firefox DevTools MCP
Mozilla има свой официален сървър, засега в ранна версия:
claude mcp add firefox-devtools npx @mozilla/firefox-devtools-mcp@latestУстроен е подобно: снимка на страницата с номера на елементите, натискане и въвеждане по номер, екранни снимки, режим без прозорец. Трябва, когато грешката се възпроизвежда именно във Firefox. Авторите съветват да се създава за него отделен профил и да не се свързва основният.
За Safari отделен сървър не намерих. Двигателят WebKit, върху който е построен, е достъпен през Playwright: флагът --browser webkit.
Свой скрипт
Най-простият начин често се забравя: никакви сървъри, агентът пише обикновен скрипт с Playwright или Puppeteer и го стартира през Bash.
import { chromium } from 'playwright';
const browser = await chromium.launch();const page = await browser.newPage();await page.goto('http://localhost:3000/login');await page.getByRole('button', { name: 'Вход' }).click();console.log(await page.getByRole('alert').textContent());await page.screenshot({ path: 'login.png' });await browser.close();Агентът стартира скрипта, чете отпечатания текст, а снимката я отваря с инструмента Read и я гледа като картинка.
Този начин има три достойнства. В контекста попада само онова, което скриптът е отпечатал. Скриптът остава в хранилището и се превръща в тест. И работи еднакво на лаптопа, в контейнера и в CI. Недостатъкът е един: това не е диалог със страницата. Всяко „а какво има там сега“ е ново стартиране.
Ако в проекта вече има сквозни тестове, това е и най-добрият начин за проверка: агентът дописва тест и го стартира. На същото са построени вградените скилове /run и /verify: те сами определят типа на проекта, стартират приложението и гледат резултата, а /run-skill-generator записва намерения рецепт за стартиране в скил на проекта.
Облачни браузъри и услуги за събиране на данни
Отделен клас са услугите, където браузърът работи на чужди сървъри, а агентът го управлява през MCP. Всички те са външни и платени или с ограничен безплатен план.
| Услуга | За какво е |
|---|---|
| Browserbase | браузъри в облака; управление чрез описание на действието с думи |
| browser-use | управлява вашия локален Chrome или облачния браузър на услугата |
| Firecrawl | не управление, а събиране: страница или цял сайт се превръщат в Markdown |
| Bright Data | събиране на данни и браузър с заобикаляне на защитата от роботи |
Нужни са там, където локалният браузър не стига: стотици страници паралелно, сайтове със защита от автоматизация, друга държава в адреса. За проверка на собственото приложение не са нужни. И помнете, че страниците и въведените данни при това минават през сървърите на трета страна.
Как да изберете
- Да проверите своя сайт на локалния сървър – вграденият браузър на Desktop или Playwright; в проект с тестове – свой скрипт.
- Да направите нещо в услуга, където вече сте влезли – Claude in Chrome. Или Playwright с флага
--extension. - Да намерите защо страницата е бавна или какво пада в конзолата – Chrome DevTools MCP.
- Работа на сървър, в контейнер, в CI – Playwright CLI, Playwright MCP с
--headlessили свой скрипт. Разширението за Chrome там не работи. - Грешка само в един браузър – Playwright с нужния
--browserили сървърът на Mozilla. - Масово събиране на данни – облачните услуги.
Две предупреждения за всички варианти наведнъж. Съдържанието на страницата е чужд текст и в него може да има инструкции, адресирани до агента; колкото повече ваши входове има браузърът, толкова по-скъпа е грешката. И всеки MCP сървър за браузър се стартира извън пясъчника, с вашите права.
Настолни и мобилни приложения
С браузъра е ясно. А какво ако нужната програма не е сайт? Настолно приложение, редактор на макети, среда за разработка, симулатор на телефон. Начините да се стигне до тях също са няколко и общият принцип е същият като при браузъра: колкото по-тесен и по-точен е инструментът, толкова по-добре. Да гледате екрана и да местите мишката е последното средство.
Самият Claude Code преглежда вариантите в такъв ред: готов конектор или MCP сървър на програмата → команда в терминала → браузър → панел на симулатора → управление на екрана. Ще ги разгледаме в същия ред.
Да не пипаме прозореца: файлове и команден ред
Най-надеждният начин да се работи с програма е изобщо да не се отваря.
Файлове. Документ на Word, таблица на Excel, презентация – това са файлове с известни формати. Агентът ги чете и създава с библиотеки, с малък скрипт, и за това има готови скилове. Приложението Office при това не се стартира.
Команден ред. При много настолни програми има режим без прозорец. Blender рендира сцена от командния ред, Android Studio билдва проекта през Gradle, Xcode – през xcodebuild, Docker Desktop се управлява с командата docker. На агента му стига инструментът Bash.
Скриптови интерфейси на операционната система
Следващото ниво е програмата да е стартирана, но да се управлява не с мишка, а през програмен интерфейс, предвиден от системата. До тях агентът стига с обикновени команди на обвивката.
| Система | Интерфейс | Какво умее |
|---|---|---|
| Windows | PowerShell и COM | да управлява приложенията на Office като обекти: да отвори работна книга, да попълни клетки, да запази |
| Windows | UI Automation | да чете дървото на елементите на всеки прозорец и да ги натиска; това е интерфейсът за екранните четци |
| macOS | AppleScript, JXA | да праща команди на приложения, които поддържат сценарии: Finder, Mail, Safari, Notes |
| Linux | xdotool, ydotool | да имитира клавиатура и мишка, да мести прозорци |
Пример за Windows. Така агентът записва стойност в отворена таблица на Excel, без да вижда прозореца ѝ:
$excel = New-Object -ComObject Excel.Application$excel.Visible = $true$book = $excel.Workbooks.Open("C:\reports\sales.xlsx")$book.Sheets.Item(1).Range("B2").Value2 = 1250$book.Save()$excel.Quit()А така на macOS моли Finder да покаже папка:
osascript -e 'tell application "Finder" to open folder "Documents" of home'Разликата с управлението с мишка е принципна. Командата „запиши 1250 в клетка B2“ или е изпълнена, или е върнала грешка. Не ѝ пречат нито разделителната способност на екрана, нито изскочил отгоре прозорец, нито сменена тема на оформлението.
На macOS такива сценарии изискват разрешения в системните настройки: „Автоматизация“ за командите към приложенията и „Универсален достъп“ за управление на интерфейса. На Linux xdotool работи само под X11, за Wayland трябва ydotool.
MCP сървъри на програмите
Много програми вече сами дават на агентите официален вход – MCP сървър. Това е най-удобният път: програмата обявява ясни инструменти, а не ви кара да налучквате къде да натиснете.
| Програма | Сървър | Какво дава |
|---|---|---|
| Figma | официален, от Figma | контекст на макета, променливи, снимки, запис върху платното |
| IDE от JetBrains | вграден в IDE от версия 2025.2 | билд, грешки във файла, стартиране на конфигурации, търсене и рефакториране |
| Xcode | официален плъгин от Apple | билд и тестове, преглед на SwiftUI, симулатори, логове от билда |
| Unity | официален плъгин и сървъри на общността | сцени, обекти, скриптове, тестове |
| Blender | от общността | изпълнение на Python вътре в Blender, рендиране на сцена |
| Симулатор на iOS, Android | от общността | дърво на елементите на екрана, натискания, снимки |
Такъв сървър се свързва като всеки друг. Например Figma:
claude mcp add --transport http figma https://mcp.figma.com/mcpС IDE е отделна история: освен MCP сървъра, JetBrains и VS Code имат собствена интеграция с Claude Code. През нея агентът вижда отворения файл, избрания фрагмент и грешките, които показва редакторът, а редакциите се появяват в прозорец за сравнение.
Има и сървъри с общо предназначение, които отварят на агента целия работен плот: за Windows – сървър на общността, който чете дървото на елементите на прозорците през UI Automation, натиска, пише и стартира PowerShell; за macOS – сървър, който изпълнява сценарии на AppleScript. Това е мощно и затова опасно: по същество е пълен достъп до системата. Самите автори предупреждават за това. Към сървърите на общността трябва да се отнасяте като към всяка чужда програма с такива права: да погледнете кода, да погледнете какво изпраща навън.
Приложения на Electron
Много настолни програми – Slack, VS Code, Discord, Notion – са написани на Electron. Отвътре това е браузърът Chromium и към него е приложимо всичко от раздела за браузърите.
Ако е ваше собствено приложение, Playwright има поддръжка на Electron, засега експериментална: скриптът стартира приложението, получава прозорците му и работи с тях като със страници.
import { _electron as electron } from 'playwright';
const app = await electron.launch({ args: ['main.js'] });const window = await app.firstWindow();await window.getByRole('button', { name: 'Нов документ' }).click();await window.screenshot({ path: 'app.png' });await app.close();Вторият път е да се стартира приложението с порт за дебъгване, с флага --remote-debugging-port, и към този порт да се свърже Chrome DevTools MCP по същия начин, както към обикновен Chrome.
Мобилни приложения
iOS. В приложението Desktop на macOS има панел със симулатор на iOS. Агентът билдва приложението, инсталира го в симулатора, натиска, въвежда текст и прави снимки. Управление на екрана за това не се ползва: панелът работи през щатните средства на Apple, затова системни разрешения за запис на екрана не са нужни. Работи само със симулатор, не с истински телефон.
От терминала същото се прави с командата xcrun simctl и с MCP сървъри за симулатора.
Android. Тук всичко се държи на adb, щатната помощна програма на Android. Чрез нея агентът инсталира билда на емулатор или на свързан телефон, стартира екран, чете логове, прави снимка, натиска по координати:
adb install -r app/build/outputs/apk/debug/app-debug.apkadb shell am start -n com.example.app/.MainActivityadb logcat -d -t 200adb exec-out screencap -p > screen.pngИма и MCP сървъри за мобилни устройства, които вместо координати дават дърво на елементите на екрана – както Playwright за страниците.
Управление на компютъра: когато останалото не е станало
Управлението на компютъра (computer use) е когато агентът работи с машината като човек: гледа екранна снимка, движи мишката, натиска клавиши. Така може да се стигне до онова, което няма нито команден ред, нито програмен интерфейс: стара корпоративна програма, панел за управление на оборудване, собственически инструмент.
Къде е достъпно. В приложението Desktop – на macOS и на Windows. В терминала – само на macOS, включва се през /mcp. Възможността е отбелязана като предварителна и изисква личен абонамент.
Как е устроено от гледна точка на сигурността:
- Достъпът се дава по приложения. Агентът иска разрешение за конкретна програма и вие го давате за сесията.
- Приложенията имат различни нива. Браузърите – само да се гледа. Терминалите и редакторите на код – да се гледа и да се кликва, но не и да се пише: иначе това би бил пълен достъп до обвивката в обход на всички правила. Останалото – пълно управление.
- Може да работи само една сесия наведнъж. Останалите програми за времето на хода се скриват, а терминалът със самия Claude Code не попада в снимките.
- Esc прекъсва работата от всяко място.
Защо това е последното средство. То е най-бавното: всяко действие е екранна снимка и заявка към модела. Най-крехкото: местне ли се бутонът, агентът пропуска. И пясъчник тук няма: агентът действа на истинския работен плот, с вашите права, а съдържанието на екрана е още един канал, през който в него може да попадне чужд текст с инструкции.
Наблизо е Dispatch – възможност да дадете задача от телефона на приложението Desktop на вашия компютър. То само стартира сесия, а на вас идва известие, когато работата е свършена или е нужно потвърждение.
Как да изберете
| Какво е нужно | С какво да се прави |
|---|---|
| Да се създаде или промени документ, таблица, презентация | работа с файла, без стартиране на програмата |
| Да се билдне, стартира, рендира | команден ред на програмата |
| Да се управлява приложение на Office на Windows | PowerShell и COM |
| Команди към приложения на macOS | AppleScript |
| Макети, IDE, игрови двигател, 3D редактор | MCP сървър на тази програма |
| Собствено приложение на Electron | Playwright |
| Приложение за iOS | панелът със симулатор в Desktop или xcrun simctl |
| Приложение за Android | adb |
| Програма без какъвто и да е програмен вход | управление на компютъра |
Работа без човек
Всичко описано по-горе е за интерактивния режим, където седите до него. Но същият двигател се стартира и без интерфейс.
claude -p "Намери в логовете причината за падането и я опиши в един абзац" --output-format jsonФлагът -p означава: изпълни задачата, отпечатай резултата и излез. Изходът е от три вида: обикновен текст, един JSON с резултата, цената и идентификатора на сесията, или поток от JSON събития по хода на работата. Може да се зададе схема и тогава отговорът ще дойде в строго зададена структура.
Какво е важно в този режим:
- Няма кого да се пита. Всичко, което би изисквало потвърждение, се отхвърля. Нужните действия се разрешават предварително: с флага
--allowedToolsили с режима на разрешенията. - Прозорецът за доверие към папката не се показва. Затова така трябва да се стартира само в папки, на които имате доверие.
- Има ограничител на бюджета:
--max-budget-usdще спре работата, когато е похарчена зададената сума. - Има „гол“ режим
--bare: без хукове, плъгини, памет и автоматично четене на инструкции. Дава предсказуем резултат в скриптове, където средата на машината не бива да влияе на отговора.
Върху този режим са построени готови интеграции: действие за GitHub Actions и шаблон за GitLab CI, които стартират агента при събитие в хранилището – нова заявка за сливане (pull request), паднал билд, споменаване в коментар.
А ако трябва да вградите агента в своя програма, има Agent SDK за Python и TypeScript. Това е същият цикъл, същите инструменти и същата работа с контекста, само че във вид на библиотека: извиквате функция и получавате поток от събития.
Фонови сесии
Интерактивната сесия заема терминала. Ако задачата е за час и няма смисъл да я гледате, сесията може да се отведе на фон.
claude --bg "Обнови зависимостите и поправи онова, което се счупи"claude agentsПървата команда стартира сесията на фон и веднага връща управлението. Втората отваря екран със списък на всички фонови сесии, подредени по състояние: чака вашия отговор, работи, приключила. От списъка може да влезете във всяка, да погледнете и да излезете обратно, без да я спирате. Вече вървяща сесия се отвежда на фон с командата /background.
Как работи отвътре. Фоновите сесии ги следи служебен процес-супервизор. Той стартира сам, държи списъка със сесиите, рестартира паднали и спира онези, които час стоят без работа и без надзор. Състоянието му лежи в папките daemon и jobs на домашната директория. Заспиването на компютъра сесиите го преживяват, рестарта – не: след него се отбелязват като спрени и продължават, когато влезете в тях.
За да не ви пречат фоновите сесии и да не си пречат една на друга, всяка преди първата редакция се мести в собствено работно копие на хранилището. В основния клон не правят push и сами нищо не сливат.
Как си взаимодействат сесиите и агентите
Начините да накарате няколко агента да работят заедно вече са четири. Те решават различни задачи и да се избира между тях е по-лесно, ако ги видите един до друг.
| Субагенти | Сценарии (workflows) | Екипи от агенти | Съобщения между сесиите | |
|---|---|---|---|---|
| Кой управлява | главният агент | скриптът | агентът-лидер | вие или самите агенти |
| Общуват помежду си | не, само отчет към главния | не, резултатите ги събира скриптът | да, директно | да |
| Контекст | у всеки свой, чист | у всеки свой | у всеки свой | у всяка сесия свой |
| Брой | единици | до стотици | няколко | колкото сесии са отворени |
| Кога да се вземе | разузнаване, независимо парче работа | голяма еднотипна работа | задача, където участниците трябва да спорят и да се договарят | вече вървящите сесии трябва да обменят сведения |
Субагентите са описани по-горе: главният агент раздава задачи и получава отчети. Помежду си те не общуват.
Сценарии (dynamic workflows). Когато субагентите са много, да се управляват от разговора става неудобно: всеки отчет попада в контекста на главния агент. Сценарият решава това иначе. Агентът пише малък скрипт на JavaScript, а харнесът го изпълнява: стартира агенти паралелно или във верига, предава резултатите от стъпка на стъпка. Междинните резултати остават в променливите на скрипта и не заемат контекст. Типичен пример – да се проверят двайсет файла по пет критерия и всяка находка да се провери отново от отделен агент. Стартира се с думата ultracode в съобщението или с молба „използвай workflow“. Преди стартиране харнесът иска потвърждение, защото десетки агенти са десетки сесии по разход.
Екипите от агенти (agent teams) са експериментална възможност, изключена по подразбиране. Тук участниците са по-равноправни: има лидер и няколко партньори, общ списък със задачи и пощенски кутии. Партньорите си пишат директно, вземат задачи от общия списък и отбелязват свършеното. Подходящо е там, където работата изисква обсъждане: единият изследва хипотеза, другият я оборва.
Съобщения между сесиите. Обикновените независими сесии – в съседни терминали, на фон – също могат да си пишат. Агентът вижда списък с достъпните събеседници и изпраща съобщение по името на сесията. На една машина съобщенията вървят директно, през локален канал, без сървърите. Между машини – през сървърите на Anthropic и за това е нужен вход в акаунт.
Тук има вградена защита, която си струва да се разбира. Съобщението от друга сесия идва като обикновен текст с бележка от кого е. То не може да потвърди заявка за разрешение, да промени настройки или да изпълни команда. Чужда сесия може да помоли, но не и да заповяда. А в настройките може да се избере какво да се прави с входящите: да се доставят, да се задържат или да се отхвърлят.
График
Агентът може да се стартира по график на три нива.
Вътре в сесията. Командата /loop 5m провери дали билдът е приключил повтаря задачата, докато сесията е отворена. Без интервал агентът сам избира паузата между проверките. Работи само докато сесията е жива и е свободна.
На вашата машина. Приложението Desktop умее да стартира задачи по график локално, с достъп до вашите файлове. Компютърът при това трябва да е включен.
В облака. Командата /schedule създава задача, която се изпълнява на сървърите на Anthropic. Вашият компютър може да е изключен. Стартира се по график (не по-често от веднъж на час), със заявка към API или при събитие в GitHub, например при отваряне на pull request.
Отдалечена работа
Последната голяма тема: как да работите с агент, който не е там, където сте вие. Вариантите са четири и се различават по това къде се изпълнява кодът.
Отдалечено управление
Агентът работи на вашия компютър, а вие го управлявате от телефона или от браузър на друга машина.
claude remote-controlСлед тази команда сесията се появява в claude.ai/code и в приложението на телефона. Оттам може да пишете съобщения, да гледате какво прави агентът, да потвърждавате разрешения.
Как е устроена връзката. Вашият компютър сам се свързва със сървърите на Anthropic с изходяща HTTPS заявка и чака съобщения. Входящи портове не отваря, нищо не трябва да се препраща. Кодът, файловете, инструментите и MCP сървърите остават на вашата машина; през сървърите минава само кореспонденцията: съобщенията, отговорите и сведенията за извикванията на инструменти.
Изисквания: вход през акаунт с абонамент, с ключ за API не работи. И процесът трябва да продължава да работи: затворите ли терминала, управлението изчезва.
Облачни сесии
Тук агентът работи на виртуална машина на Anthropic. Вашият компютър изобщо не е нужен.
claude --cloud "Добави проверка на формата на телефона във формата за регистрация"Същото се прави от сайта claude.ai/code и от телефона. Машината получава вашето хранилище от GitHub, агентът работи в отделен клон и в края предлага pull request.
Какво си струва да знаете за тази среда:
- Средата се настройва. Може да се зададе скрипт за подготовка, който да инсталира нужните пакети, променливите на средата и нивото на достъп до мрежата: никакъв, ограничен (регистри на пакети и GitHub) или пълен.
- Ключовете за GitHub не попадат в машината. Те остават на сървърите на Anthropic, а заявките към GitHub минават през прокси, което ги подставя само.
- Машината заспива. След няколко минути бездействие тя се поставя на пауза; фоновите процеси при това не се запазват.
- Сесията може да се вземе при вас. Командата
/teleportпренася облачния разговор и клона във вашия терминал. В обратната посока, от терминала в облака, готова сесия не може да се пренесе.
Свързване по SSH от приложението
В приложението Desktop в списъка със среди има точка SSH. Посочвате адреса на машината, приложението само инсталира на нея Claude Code и стартира там сесия. Интерфейсът остава при вас, а кодът се изпълнява на отдалечената машина. Постоянните връзки се описват в настройките:
{ "sshConfigs": [ { "id": "dev-vm", "name": "Dev VM", "sshPort": 22 } ]}Виртуална машина в мрежата: как да я сглобите сами
Сега един често срещан практически случай. Имате своя виртуална машина – в облака или в локалната мрежа – и искате агентът да работи на нея. Причините обикновено са две. Първата е изолацията: на машината няма вашите лични файлове и ключове и на агента може да се позволи повече. Втората е непрекъснатостта: машината не заспива заедно с лаптопа.
Claude Code е обикновена програма за Linux, затова начините са няколко.
Първи начин: SSH и tmux. Влизате на машината по SSH, стартирате tmux, а в него – claude. tmux трябва, за да преживее сесията прекъсване на връзката: изключили сте се, свързали сте се пак, върнали сте се в същия терминал. Това е най-простият вариант и работи навсякъде.
Втори начин: отдалечено управление от машината. На машината в tmux стартирате claude remote-control и нататък работите с нея от телефона или от браузър. SSH е нужен само за първото стартиране. Входящи портове не е нужно да се отварят, защото машината се свързва навън сама. За командата claude remote-control има сървърен режим: една такава команда приема няколко сесии и всяка може да се стартира в собствено работно копие на хранилището.
Трети начин: фонови сесии. На машината стартирате задачите с claude --bg и гледате за тях през claude agents. Супервизорът ги държи без отворен терминал.
Четвърти начин: приложението Desktop по SSH, описано по-горе. Удобно е, ако искате графичен интерфейс и diff, а не терминал.
Пети начин: без интерфейс. Скрипт или планировчик на машината извиква claude -p със задача. Подходящо е за нощни пускания и за обработка на опашка.
Общият за всички начини въпрос е как да влезете в акаунта на машина без браузър. Вариантите са такива:
| Начин на вход | Какво дава | Какво не дава |
|---|---|---|
Обикновен вход (/login) | всичко, което има в абонамента | изисква веднъж да се отвори връзка в браузър на друго устройство |
Дългоживеещ токен (claude setup-token) | заявки към модела по абонамента, удобно за скриптове | отдалечено управление и браузър |
| Ключ за API | заявки към модела с плащане на токени | всичко, което е вързано за абонамента: отдалечено управление, облачни сесии |
И няколко съвета от практиката. Ако машината е отделена за агента, включете на нея пясъчника: това е Linux, там той работи изцяло. Давайте на машината отделен ключ за достъп до хранилището с минимални права, а не вашия личен. И помнете, че изолацията на машината пази вашата система, но не и онова, до което самата машина може да стигне по мрежата.
За организациите има още един вариант – собствени среди за облачните сесии. Стартирате на своята инфраструктура процес-изпълнител, той се свързва със сървърите на Anthropic с изходяща връзка и облачните сесии от уеб интерфейса се изпълняват на вашите машини, вътре във вашата мрежа. Това е бета за корпоративните планове.
Доставчици и локални модели
Откъде идва моделът. Основните пътища са два: абонамент за Claude или ключ за API с плащане на токени. За компаниите има трети: моделите Claude през облак – Amazon Bedrock, Google Cloud или Microsoft Foundry. Избира се с променлива на средата.
Важно е да се разбира, че част от възможностите са вързани именно за абонамента и сървърите на Anthropic. През облачен доставчик или с ключ за API не работят отдалеченото управление, облачните сесии, разширението за браузър, управлението на компютъра, приложението Desktop. Самият цикъл на агента, инструментите, паметта, скиловете, хуковете и MCP работят навсякъде еднакво.
Може ли Claude Code да се стартира с чужд или с локален модел? Официално – не: Anthropic не поддържа такъв режим. Технически адресът на API се подменя с променливата ANTHROPIC_BASE_URL и някои вендори документират свързването на свои модели по този начин. Но системният промпт и инструментите на Claude Code са пресметнати за моделите Claude и качеството с други е осезаемо по-ниско. Ако ви трябва работа със свои модели, по-добре е да вземете харнес, който е направен за това.
Лимити и цена
При абонамент разходът е ограничен с прозорци: петчасов и седмичен, плюс отделни седмични лимити за старшите модели. Те са общи за целия акаунт: терминалът, приложението, облачните сесии и обикновеният чат харчат една квота. Колко е останало, показва /usage; там се вижда и какво точно изразходва лимита – кои скилове, субагенти и MCP сървъри.
При ключ за API лимити по прозорци няма, плаща се за токени. За ориентир: документацията посочва средна цифра около 13 долара на разработчик за активен ден.
От описаното по-горе устройство пряко следва кое точно е скъпо:
- Дълга сесия след пауза. Кешът е изстинал и целият разговор се плаща наново.
- Паралелни агенти. Всеки субагент, партньор или фонова сесия е отделен разговор със свой контекст.
- Високо усилие и старши модел там, където задачата не го изисква.
- Задачи по график. Всяко задействане изпраща пълния контекст.
- Раздути инструкции. Плащат се във всяка заявка на всяка сесия.
Какво излиза от вашата машина
Кратка, но важна част.
Какво се изпраща. Към сървърите на Anthropic отива онова, което е попаднало в заявката: вашите съобщения, съдържанието на прочетените файлове, изходът на командите, отговорите на модела. Файловете, които агентът не е чел, никъде не се изпращат.
Обучение. При личните планове използването на вашите данни за обучение на модели е превключвател в настройките за поверителност. При корпоративните планове и през API данните по подразбиране не се използват за обучение.
Съхранение на сървърите. По подразбиране 30 дни; ако при личен план е разрешено обучението – до пет години.
Съхранение при вас. Разговорите лежат в домашната папка като открит текст 30 дни. Това е добре да се помни, когато агентът чете файлове с тайни.
Телеметрия. Метриките за използване и отчетите за грешки се изключват с променливи на средата; една променлива изключва целия незадължителен трафик наведнъж.
Защита от вредни инструкции. Текстът, който агентът е прочел на уеб страница, във файл или в отговор на инструмент, може да съдържа команди, адресирани до него. Срещу това работят няколко слоя едновременно: заявките за разрешения, преразказът на уеб страниците от отделен модел, прозорецът за доверие към нова папка, потвърждението за MCP сървърите на проекта. Нито един слой не дава гаранция. Затова с недоверено съдържание – чуждо хранилище, непознати сайтове – е разумно да се работи в изолирана среда.
С какво Claude Code се различава от сходните инструменти
Всички съвременни харнеси за програмиране са устроени по една схема: цикъл, инструменти, инструкции на проекта, разрешения. Различават се по решенията в детайлите. Накратко за главните; подробното сравнение на над четиридесет инструмента е в отделна статия.
| Claude Code | Codex | Cursor | GitHub Copilot | OpenCode | |
|---|---|---|---|---|---|
| Кой го прави | Anthropic | OpenAI | Anysphere | GitHub | общността, екипът на SST |
| Изходен код | затворен | CLI е отворен | затворен | CLI е затворен, разширението е отворено | отворен |
| Основна форма | терминал | терминал и облак | собствен редактор | редактор и GitHub | терминал |
| Модели | само Claude | модели на OpenAI | на много вендори | на много вендори | всякакви, включително локални |
| Инструкции | CLAUDE.md, правила по пътища | AGENTS.md | .cursor/rules | copilot-instructions.md | AGENTS.md |
| Търсене в кода | агентно, без индекс | агентно | индекс с ембединги плюс агентно | индекс плюс агентно | агентно |
| Пясъчник | по желание; няма на Windows без WSL | включен по подразбиране на трите ОС | включен на macOS и Linux | по желание | няма |
| Облачен режим | има | има | има | има | няма |
Какво следва от това на практика.
Силните страни на Claude Code са дълбочината на настройката и работата без надзор. Четири нива на инструкции, правила с връзка с пътища, скилове, субагенти със собствен модел, над тридесет събития за хукове, модове, сценарии с десетки агенти, фонови и облачни сесии. При никой друг няма такъв набор изцяло.
Слабите страни са затвореният код и привързването към един вендор. Може да се работи само с моделите Claude, а абонаментът действа само в продуктите на Anthropic. Пясъчникът не е включен по подразбиране и не работи на Windows без WSL – при Codex е включен веднага и на трите системи.
Какво се пренася. Файловете от папката .claude станаха нещо като общ формат: скиловете, правилата и хуковете частично ги четат Cursor, Copilot, OpenCode и други. А AGENTS.md, който разбират почти всички, Claude Code го чете, ако няма собствен файл с инструкции. Командата /import пренася настройки в обратната посока – от Codex, Gemini CLI и Cursor.
Накратко
- Claude Code е харнес: програма на вашия компютър, която дава на модела инструменти и управлява онова, което моделът вижда. Моделът мисли, харнесът действа.
- Работата върви на цикъл: моделът моли да се извика инструмент, харнесът изпълнява и връща резултата, и така до отговор без извиквания. Всяка заявка носи целия разговор.
- Редакцията на файл е точна замяна на уникално парче. Търсенето е обикновено търсене по файлове, без индекс.
- Контекстът се свива сам. Свиването преживява онова, което е записано във файлове: инструкции, правила, памет. Казаното само в чата може да се загуби.
- Знанието се предава по три начина: инструкции и правила (винаги в контекста), скилове (при поискване), автоматична памет (пише я самият агент, лежи в домашната папка).
- Субагентът е отделен контекст за отделна задача. Спестява главния контекст, но губи детайли при предаването и струва като още една сесия.
- Хукът е код, който харнесът изпълнява сам. Всичко, което трябва да се случва винаги, се прави с хук, а не с ред в инструкциите.
- Разговорите, паметта и копията на файлове лежат в
~/.claudeкато открит текст. Настройките на проекта са в.claudeв хранилището. - Разрешенията и авторежимът пазят от случайности. Истинската граница дават пясъчникът, контейнерът и виртуалната машина.
- Един двигател работи в терминала, в редактора, в приложението, в облака и без интерфейс. На вашата виртуална машина той се стартира като обикновена програма за Linux, а да се управлява може от телефона, без да се отварят портове.
Източници
- How Claude Code works – цикълът на агента, контекст, сесии.
- Tools reference – всички вградени инструменти и поведението им.
- Explore the context window – какво се зарежда в контекста и какво преживява свиването.
- Explore the .claude directory – файловете на проекта и на домашната папка.
- Memory, Skills, Subagents, Hooks, MCP.
- Permission modes, Permissions, Sandboxing, Security, Data usage.
- Checkpointing, Worktrees, Development containers.
- Claude in Chrome, Computer use, Desktop.
- Remote Control, Claude Code on the web, Self-hosted environments.
- Headless mode, Agent view, Agent teams, Workflows, Cross-session messaging.
- Model configuration, Costs, Feature availability.