Въведение: Агентът, който всеки иска, без излишния шум
Проблемът с кодиращите агенти е, че повечето от тях се опитват да бъдат ваш шеф, ваш съ-пилот и ваш терапевт – а след това забравят просто да напишат кода. Схемата е следната: добавят дузина векторни хранилища, поръсват малко оркестриращ магически прах, връзват браузър и казват, че са готови. Демонстрира се добре. Също така се разпада в момента, в който го помолите да поправи нестабилен интеграционен тест в 16:52 в петък.
Изграждането на лек кодиращ агент с Claude 4.5 е – изненада – всъщност е доста лесно, ако спрете да преследвате мечтата за универсален софтуерен иконом и просто създадете инструмент, който чете код, планира, редактира, изпълнява и повтаря. Без проповеди за „AI, заменящ разработчиците“. Без Rube Goldberg вериги. Просто стегнат цикъл, който върши очевидните неща добре.
Това е ръководство „как да“ за постигане на това, без да влачите цял отдел за AI операции. Ще използваме Claude 4.5 за мозък, файлова система и shell за ръце и малка памет за краткосрочен фокус. Това е всичко. Лек означава, че можете да го разберете за едно сядане, да го стартирате локално и да му се доверите, защото всяка стъпка може да бъде инспектирана. Което, ако сте използвали нещо в тази област напоследък, е почти подривно.
Защо Claude 4.5 работи за минимален агент
Claude 4.5 има темперамента, който всъщност искате за код: внимателен при следване на инструкции, изненадващо добър в четенето на diff-ове и не е прекалено нетърпелив да халюцинира рамки, които не сте поискали. Моделът е компетентен в поетапното разсъждение, без да изисква цял роман от подкани. Тази комбинация – разсъждение плюс сдържаност – го прави идеален за цикъл на кодиращ агент:
- Наблюдение: Четене на текущи файлове, логове за грешки и тестове.
- Планиране: Предлагане на конкретни редакции с обосновка.
- Действие: Закърпване на файлове, изпълнение на команди.
- Отражение: Оценяване на изхода, итериране или спиране.
Можете да прикрепите това към всяко repo и да получите стойност за един следобед. Номерът е да устоите на желанието да го превърнете в „AI платформа“. Ако поддържате агента лек, Claude 4.5 върши тежката работа, без да ви пречи.
Леката архитектура: Пет части, без драма
Ето целия stack, от който се нуждаете:
- Основен цикъл: Един процес, който извиква Claude 4.5 и интерпретира неговите tool-use съобщения.
- Инструменти: Малък набор – read_file, write_file, list_dir, run_tests (или run_cmd), search_code.
- Контекстен конструктор: Съставяне на кратка, насочена подкана с repo метаданни и скорошни diff-ове.
- Краткосрочна памет: Плъзгащ се прозорец за разговори плюс ясен scratchpad за план и ограничения.
- Предпазни мерки: Ограничения за токени, време и запис на файлове; режим на пробно изпълнение; и rollback снимки.
Това е всичко. Можете да го стартирате headless в терминал или да го увиете в минимален UI, ако трябва. Причината това да работи е скучна: всяко действие се наблюдава и може да бъде проверено. Агентът предлага промяна, показва diff-а, изпълнява тестовете, чете изхода и или продължава, или спира. Няма мистериозно месо в средата.
Как да изградим агента (без да губим нишката)
Стъпка 1: Определете договора – подкана и инструменти
Вашият агент е толкова добър, колкото е неговият договор с модела. Поддържайте системната подкана кратка, строга и безмилостно практична.
Системна подкана, дестилирана:
- Вие сте кодиращ агент. Вашата работа е да правите малки, правилни промени в repo-то, за да изпълните задачата на потребителя.
- Мислете на глас в скрит scratchpad; показвайте само планове и diff-ове на потребителя.
- Предпочитайте минимални diff-ове, работещи тестове и инкрементален прогрес.
- Когато не сте сигурни, предложете експеримент и го изпълнете.
- Никога не измисляйте файлове или команди – изброявайте и четете, преди да редактирате.
Схема на инструментите (не го усложнявайте прекалено много):
- read_file(path, offset?, length?)
- write_file(path, content, create_if_missing=false)
- run_cmd(command, timeout=60, cwd=repo_root)
- search_code(query, path=repo_root, max_results=50)
Незадължителни екстри: git_diff и git_revert(sha), ако искате rollbacks без ръце. Можете да пропуснете векторно хранилище; повечето полезни задачи зависят от няколко файла в работната памет плюс бързо търсене.
Стъпка 2: Поддържайте контекста стегнат
Натъпкването на контекст е карго култът на дизайна на агенти. Не изхвърляйте цялото си monorepo в подканата. Вместо това:
- Обобщение на Repo: Един параграф README digest; входни точки; команда за изпълнение на тестове.
- Активни файлове: Само файловете, които агентът планира да докосне – четете ги на части, ако е необходимо.
- Задача: Целта на потребителя, ясно формулирана: „Поправете неуспешен тест FooTest.test_bar в tests/foo_test.py.“
- Ограничения: Ограничения за време на изпълнение, бял списък за запис на файлове, правила за стил и очаквания за семантично номериране на версиите, ако е приложимо.
- Скорошна история: Последните два diff-а и техните резултати от тестовете. Нищо друго.
Claude 4.5 е напълно способен да извлече повече контекст, когато се нуждае от него, чрез search_code и read_file. Дайте му картата, а не територията.
Стъпка 3: Цикълът (Наблюдение → Планиране → Действие → Отражение)
- Наблюдение: Започнете с изброяване на директории, четене на неуспешния тест, кода в процес на тестване и лога за грешки. Помолете Claude да обобщи симптомите на повреда в два или три маркера.
- Планиране: Накарайте Claude да предложи план с:
- Файлове за инспектиране или редактиране
- Минимални diff-ове за опит
- Команда за тест за валидиране
- Действие: Приложете предложения diff чрез write_file. Покажете diff-а буквално. Изпълнете тестовете.
- Отражение: Върнете stdout/stderr обратно. Попитайте Claude: да продължи, да се върне назад или да спре? Ако планът се промени, изисквайте обосновка в едно изречение, позоваваща се на действителния изход.
- Изход: Спрете, когато тестовете преминат, или след N итерации, което дойде първо.
Това е прославено програмиране по двойки, където всъщност поддържате честността на двойката.
Стъпка 4: Предпазни мерки, които спасяват уикенда ви
- Бял списък за запис: Позволете записи само в src/, lib/ или изрично одобрени пътища.
- Ограничение за размера на Diff: Ограничете редакциите до 200–500 реда на стъпка. Ако е по-голям, разделете на подстъпки.
- Списък с разрешени команди: тестови ранери, линтери и няколко dev скрипта. Забранете мрежата. Искате възпроизводимост, а не curl от дивия запад.
- Време за изчакване и повторни опити: Кратки времена за изчакване, максимум един повторен опит – безкрайните цикли за повторно изпълнение са мястото, където агентите отиват да умрат.
- Режим на пробно изпълнение: Отпечатайте предложените diff-ове, но не пишете. Чудесно за code review.
Claude 4.5 ще се придържа към правилата, ако ги направите ясни. Ако не го направите, не се изненадвайте, когато се опита да „помогне“, като реорганизира цялото ви repo, за да отговаря на публикация в блог от 2017 г.
Стъпка 5: Памет, която всъщност е полезна
Краткосрочната памет решава 80% от проблема. Запазете:
- Scratchpad за текущата хипотеза и план.
- Списък на файловете, докоснати в тази сесия.
- Последните два изхода от командите.
Това е достатъчно за Claude 4.5 да разсъждава последователно. Дългосрочната памет – логове на задачи, embeddings – може да бъде полезна за повтарящи се codebases, но я третирайте като незадължителна добавка. Ако вашият агент не може да поправи тест без 500MB векторна индекс, той не е агент – той е зависимост.
Минималната скица за изпълнение
В псевдокодни термини можете да приложите този агент в няколкостотин реда:
- initialize: зареждане на repo метаданни, ограничения и модел клиент
- observe: четене на неуспешни тестове, файлове, логове
- plan = model.propose_plan(context)
- while not done and steps < MAX:
- diff = model.propose_patch(plan)
- show(diff); maybe approve
- out = run_cmd(plan.test_cmd)
- reflect = model.evaluate(out)
- if reflect == pass: done = true
- else if reflect == rollback: git_revert(last_commit)
- else: plan = model.revise_plan(out)
Ще забележите липсващите части: няма агенти, управляващи агенти, няма „делегати“, няма отделен „модел за планиране“ и „модел за изпълнение“. Claude 4.5 може да свърши и двете работи добре, ако не го саботирате с Rube Goldberg апарат.
Подкани, които не се опитват твърде много
Лошите подкани се опитват да бъдат умни. Добрите подкани са скучни и специфични. Ето разумен скелет за вашия основен инструкционен блок:
- Цел: Посочете точната задача за кодиране и критериите за успех.
- Контекст: Структура на проекта, входни точки и команда за тест.
- Ограничения: Бял списък за запис, ограничение за размера на diff, без мрежа.
- Предпочитания за стил: Езикова версия, форматиране, правила за линтер.
- Процес: Наблюдение → Планиране → Действие → Отражение; показване на diff-ове; изпълнение на тестове; итериране до N стъпки; спиране, когато тестовете преминат.
Claude 4.5, с тази структура, няма да се нуждае от сценарий за ролева игра от 100 реда. Просто работи.
Практически пример: Поправете неуспешен тест
Да кажем, че тестът е неуспешен в tests/time_test.py, защото parse_time("09:00") връща 5400 вместо 32400. Цикълът на агента трябва да изглежда така:
- Наблюдение: Четене на time.py и time_test.py; изпълнение на pytest -k parse_time.
- Планиране: Хипотеза – грешка в математиката на секунди спрямо минути; предлага редактиране на parse_time; добавяне на edge case за единици часове.
- Действие: Закърпване на parse_time, добавяне на тест за часове с водеща нула; изпълнение на тестове.
- Отражение: Ако тестовете все още са неуспешни, прочетете грешката, коригирайте математиката или regex, изпълнете отново.
Минималният успешен patch може да бъде промяна от два реда. Това е идеята. Малки редакции, бързи цикли, реален напредък.
Къде лекото побеждава кухненската мивка
- Латентност: Един модел, един цикъл, без режийни разходи за оркестрация.
- Прозрачност: Всяка стъпка може да бъде одитирана. Можете да я diff-нете, можете да я върнете, можете да я изпълните отново.
- Контрол: Предпазните мерки поддържат локално увреждане. Агентът не може да се отклони във вашата инфраструктура.
- Цена: По-малко извиквания, по-малко контекст, предвидими токени.
- UX: Вие го разбирате. Вашите съотборници го разбират. Бъдещото ви аз няма да ви мрази.
И компромисите:
- Ширина: Лек кодиращ агент няма да рефакторира вашето monorepo на пет езика с едно преминаване. Нито трябва.
- Инициатива: Няма да измисля многоседмични пътни карти. Вие му давате задачи.
- Състояние: Без голям слой памет, той забравя далечна история по дизайн. Това е функция, докато не стане грешка.
Сладката точка на Claude 4.5 за кодиращи агенти
Claude 4.5 блести в:
- Четене и разсъждение за diff-ове и логове.
- Създаване на последователни, минимални промени в кода.
- Следване на ограничения и изричност относно несигурността.
Той е по-малко добър в:
- Отгатване на поведението на API, което не може да прочете.
- Тежка хореография на инструменти (не е необходима тук).
- Дълги рефактори на множество файлове без човек, който да ръководи стъпките.
Последната точка е важна. Най-добрият начин да получите силни резултати не е да направите агента по-голям – а да направите задачата по-малка. Използвайте мозъка си за обхват, а Claude 4.5 за изпълнение в рамките на този обхват.
Една дума за IDE интеграция
Устойте на желанието да вградите това директно в IDE прозорец с петдесет превключвателя. Базиран на терминал цикъл с обикновени текстови diff-ове е по-лесно да се доверите и да го отстраните. Ако искате editor sugar, поддържайте го тъп:
- Команди за стартиране/спиране на цикъла.
- Показване на diff-ове в разделен изглед.
- Подкана за одобрение за записи (незадължително, но мъдро).
Можете да интегрирате по-късно. Първо го накарайте да работи.
Sider.AI, използван пестеливо, всъщност помага Ако искате прагматична среда за изпълнение на този вид цикъл, без да изобретявате отново скелето, Sider.AI всъщност работи – поне когато го използвате за това, в което е добър. Той поддържа разговора и diff-овете подредени, позволява ви да изпълнявате команди и не ви насилва да използвате някаква грандиозна „автономна рамка за агенти“. Номерът е да поддържате собствените си правила: кратки подкани, стегнати цикли, видими diff-ове. Sider се отдръпва от пътя, което е по-рядко, отколкото трябва да бъде. Чести клопки (и как да избегнете да изглеждате глупаво)
- Препълнен контекст: Ако вашата подкана звучи като бележка за откуп, правите го погрешно. Извличайте файлове при поискване.
- Преждевременно рефакториране: Агентът предлага реорганизиране на модулите? Накарайте го първо да премине тестовете. Рефакторирайте по-късно.
- Халюцинирани файлове: Изисквайте list_dir и read_file преди всеки write_file към нов път.
- Безкрайни цикли за повторно изпълнение: Ограничете стъпките. Изисквайте обосновка за всяка нова хипотеза.
- Един гигантски diff: Разделете промените. По-малките diff-ове се провалят по-бързо и е по-лесно да се разсъждава за тях.
Сигурност и безопасност без параноя
- Локално изпълнение: Изпълнете в изолирана директория. Без мрежа по подразбиране.
- Изолиране на зависимостите: Използвайте локален venv или контейнер. Закачете версии.
- Тайни: Агентът не се нуждае от тях. Ако дадена команда изисква токен, спрете и попитайте.
- Одит: Запазете всеки план, diff и команда в лог.
Как да разберете, че работи
- Времето за изпълнение се свива: Поправките на грешки, които отнемаха час, сега отнемат десет минути.
- По-малко грешки с дебели пръсти: Diff-овете стават по-малки, тестовете стават по-зелени.
- Доверявате му се: Спирате да се носите над всяко действие, защото не ви е изгорил.
- Съотборниците го използват: Дефиницията за успех е, че другите го приемат без среща.
Внимателно мащабиране
Ако наистина трябва да мащабирате, направете го с дисциплина:
- Паралелни подзадачи, а не паралелни мозъци: Разделете работата, изпълнете множество леки цикъла в отделни директории и обединете, когато са зелени.
- Епизодична памет, а не изхвърляне на мозъци: Съхранявайте успешни пачове и съпоставяния на симптоми към поправки. Извличайте хирургично.
- Периодични „по-големи“ преминавания: Резервирайте ръководена от човек сесия за рефактори; агентът помага, не води.
Минимална референтна реализация (скица)
Псевдокод, подобен на Python, за да се движите:
- def init(self, repo_root, model):
- self.history = [] # last two diffs and test outputs
- "repo": summarize_repo(self.root),
- "constraints": {"write_whitelist": ["src/", "tests/"], "max_diff_lines": 300, "no_network": True},
- "history": self.history[-2:],
- plan = self.model("propose_plan", self.context(task))
- diff = self.model("propose_patch", {"plan": plan})
- out = run_cmd(plan.test_cmd)
- eval = self.model("evaluate", {"output": out, "plan": plan})
- self.history.append({"diff": diff, "out": tail(out)})
Човешки край
Индустрията продължава да обещава автономни агенти за разработчици. Това, от което всъщност се нуждаем, е честен асистент, който чете, планира, редактира, изпълнява и спира. Claude 4.5 е добър в това, при условие че не го заровите под рамки, които съществуват най-вече, за да се оправдаят. Лекото не е компромис – това е идеята. Изградете цикъла, добавете предпазните мерки и оставете инструмента да направи едно нещо, което инструментите винаги са правили, когато ги поддържате прости: да направят работата по-малка.
Заключение: Скучният пряк път, който печели
Ето вашия контролен списък за лек кодиращ агент с Claude 4.5:
- Един цикъл, един модел, малки инструменти.
- Стегнат контекст: задача, няколко файла, последни изходи.
- Минимални diff-ове, чести тестове, твърди капачки.
- Локално, изолирано изпълнение; без мрежа.
- Незадължителен editor sugar; никога не се изисква.
Ако се присмеете, изглежда подозрително като добър софтуерен инженеринг, само по-бързо. И това е кулминацията. Най-умното нещо, което можете да направите тук, не е да преследвате „автономия“ – а да кодифицирате дисциплината. Колкото по-малко искате от агента, толкова повече получавате.
FAQ
В1: Как да започна да изграждам лек кодиращ агент с Claude 4.5?
Определете малък набор от инструменти (четене, запис, търсене, изпълнение), напишете строга системна подкана и приложете цикъл Наблюдение → Планиране → Действие → Отражение. Поддържайте контекста малък и подавайте реални логове и diff-ове – Claude 4.5 се представя най-добре, когато задачата е тясна и обратната връзка е конкретна.
В2: Нуждая ли се от векторна база данни или слой памет за кодиращ агент Claude 4.5?
Не. За повечето задачи краткосрочната памет плюс search_code е достатъчна. Добавете дългосрочна памет само ако многократно посещавате същото repo и можете да докажете, че спестява токени, без да прави агента по-глупав.
В3: Кои предпазни мерки са от съществено значение за кодиращ агент Claude 4.5?
Включете в белия списък пътищата, които могат да се записват, ограничете размерите на diff, ограничете командите и регистрирайте всяко действие. Тези прости ограничения поддържат агента предсказуем и правят връщането назад скучно – по добър начин.
В4: Може ли лек агент да се справи с рефакториране на множество файлове?
Да, ако разделите работата на малки стъпки и поддържате цикъла стегнат. Claude 4.5 може да управлява рефакториране, но вие ръководите обхвата; в противен случай ще получите един гигантски, крехък diff, който няма да искате да прегледате.
В5: Къде се вписва Sider.AI с кодиращ агент Claude 4.5?
Sider.AI е полезен като подредено работно пространство: разговори, diff-ове и команди на едно място, без да се налага рамка за тежък агент. Използвайте го, за да стартирате цикъла си, а не да го изобретявате отново. 
