Introducció: L'Agent que Tothom Vol, Sense l'Hype
El que passa amb els agents de codificació és que la majoria intenten ser el teu cap, el teu copilot i el teu terapeuta; i després s'obliden simplement d'escriure el codi. La jugada és així: afegeix una dotzena de magatzems de vectors, espolvoreja una mica de pols de fades d'orquestració, subjecta un navegador i després considera que ja has acabat. Queda bé a la demo. També s'ensorra al segon que li demanes que arregli una prova d'integració poc fiable a les 16:52 d'un divendres.
Construir un agent de codificació lleuger amb Claude 4.5 és, sorpresa, realment senzill si deixes de perseguir el somni d'un majordom de programari universal i simplement construeixes una eina que llegeix codi, planifica, edita, executa i repeteix. Sense sermó sobre “la IA que reemplaça els desenvolupadors”. Sense canonades de Rube Goldberg. Només un bucle ajustat que fa les coses òbvies, bé.
Aquesta és una guia pràctica per arribar-hi sense necessitat d'arrossegar tot un departament d'operacions d'IA. Utilitzarem Claude 4.5 per al cervell, un sistema de fitxers i un shell per a les mans i una petita memòria per a l'enfocament a curt termini. Això és tot. Lleuger significa que pots entendre'l en una sola sessió, executar-lo localment i confiar-hi perquè cada pas és inspeccionable. Cosa que, si has utilitzat alguna cosa en aquest espai últimament, és gairebé subversiva.
Per què Claude 4.5 Funciona per a un Agent Mínim
Claude 4.5 té el temperament que realment vols per al codi: cura amb el seguiment d'instruccions, sorprenentment decent en la lectura de diffs i no massa ansiós per al·lucinar marcs que no has demanat. El model és competent en el raonament gradual sense exigir una novel·la de prompt completa. Aquesta combinació (raonament més restricció) el fa ideal per a un bucle d'agent de codificació:
- Observar: Llegir els fitxers actuals, els registres d'errors i les proves.
- Planificar: Proposar edicions concretes amb justificació.
- Actuar: Aplicar pedaços als fitxers, executar ordres.
- Reflexionar: Avaluar la sortida, iterar o aturar.
Pots connectar això a qualsevol repositori i obtenir valor en una tarda. El truc és resistir la temptació de convertir-ho en una “plataforma d'IA”. Si mantens l'agent lleuger, Claude 4.5 fa el treball pesat sense interposar-se en el teu camí.
L'Arquitectura Lleugera: Cinc Peces, Sense Drama
Aquí tens tota la pila que necessites:
- Bucle central: Un procés que crida Claude 4.5 i interpreta els seus missatges d'ús d'eines.
- Eines: Un conjunt petit: read_file, write_file, list_dir, run_tests (o run_cmd), search_code.
- Constructor de context: Aplegar un prompt curt i precís amb metadades del repositori i diffs recents.
- Memòria a curt termini: Una finestra de conversa rotativa més un bloc de notes explícit per al pla i les restriccions.
- Salvadors: Límits de tokens, temps i escriptura de fitxers; un mode de prova; i instantànies de reversió.
Això és tot. Pots executar-lo sense capçal en un terminal o embolicar-lo en una IU mínima si cal. La raó per la qual això funciona és avorrida: cada acció s'observa i es pot verificar. L'agent proposa un canvi, mostra el diff, executa les proves, llegeix la sortida i continua o s'atura. No hi ha carn misteriosa al mig.
Com Construir l'Agent (Sense Perdre la Trama)
Pas 1: Definir el Contracte: Prompt i Eines
El teu agent és tan bo com el seu contracte amb el model. Mantén el prompt del sistema curt, estricte i implacablement pràctic.
Prompt del sistema, destil·lat:
- Ets un agent de codificació. La teva feina és fer petits canvis correctes al repositori per satisfer una tasca d'usuari.
- Pensa en veu alta en un bloc de notes amagat; exposa només els plans i els diffs a l'usuari.
- Prefereix diffs mínims, proves de treball i progrés incremental.
- Quan no estiguis segur, proposa un experiment i executa'l.
- No fabriquís mai fitxers ni ordres; enumera i llegeix abans d'editar.
Esquema d'eines (no hi pensis massa):
- 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)
Extres opcionals: git_diff i git_revert(sha) si vols reversions mans lliures. Pots ometre un magatzem de vectors; la majoria de les tasques útils depenen d'un grapat de fitxers a la memòria de treball més una cerca ràpida.
Pas 2: Mantén el Context Lleuger
L'ompliment de context és el culte al càrrega del disseny d'agents. No aboqueu tot el vostre monorepositori al prompt. En lloc d'això:
- Resum del repositori: Resum d'una paràgrafa del README; punts d'entrada; ordre d'execució de proves.
- Fitxers actius: Només els fitxers que l'agent té previst tocar: llegiu-los en fragments segons sigui necessari.
- Tasca: L'objectiu de l'usuari, expressat de manera concisa: “Arreglar la prova fallida FooTest.test_bar a tests/foo_test.py”.
- Restriccions: Límits de temps d'execució, llista blanca d'escriptura de fitxers, regles d'estil i expectatives de versionat semàntic si escau.
- Historial recent: Els dos últims diffs i els seus resultats de prova. Res més.
Claude 4.5 és perfectament capaç d'obtenir més context quan ho necessita mitjançant search_code i read_file. Doneu-li el mapa, no el territori.
Pas 3: El Bucle (Observar → Planificar → Actuar → Reflexionar)
- Observar: Comenceu per enumerar els directoris, llegir la prova fallida, el codi en prova i el registre d'errors. Demaneu a Claude que resumeixi els símptomes de fallada en dos o tres punts.
- Planificar: Feu que Claude proposi un pla amb:
- Hipòtesi per a la fallada
- Fitxers per inspeccionar o editar
- Diffs mínims per intentar
- Una ordre de prova per validar
- Actuar: Apliqueu el diff proposat mitjançant write_file. Mostreu el diff textualment. Executeu les proves.
- Reflexionar: Torneu a introduir stdout/stderr. Pregunteu a Claude: procedir, fer marxa enrere o aturar? Si el pla canvia, exigeix una justificació d'una frase que faci referència a la sortida real.
- Sortir: Atureu quan les proves passin, o després de N iteracions, el que passi primer.
Això és una programació per parelles glorificada on realment mantens l'aparellament honest.
Pas 4: Salvadors que Salven el Teu Cap de Setmana
- Llista blanca d'escriptura: Només permet l'escriptura dins de src/, lib/ o rutes explícitament aprovades.
- Límit de mida de diff: Limita les edicions a 200–500 línies per pas. Si és més gran, divideix en subpassos.
- Llista blanca d'ordres permeses: executors de proves, linters i uns quants scripts de desenvolupament. Prohibeix la xarxa. Voleu reproductibilitat, no curl del salvatge oest.
- Temps d'espera i intents: Temps d'espera curts, un màxim d'un intent: els bucles de re-execució sense fi són on els agents van a morir.
- Mode de prova: Imprimiu els diffs proposats però no escriviu. Ideal per a la revisió del codi.
Claude 4.5 s'atindrà a les regles si les feu explícites. Si no ho fas, no t'estranyis quan intenti “ajudar” reorganitzant tot el teu repositori per adaptar-se a alguna publicació de bloc del 2017.
Pas 5: Memòria que és Realment Útil
La memòria a curt termini resol el 80% del problema. Mantingueu:
- Un bloc de notes per a la hipòtesi i el pla actuals.
- Una llista de fitxers tocats en aquesta sessió.
- Les dues últimes sortides d'ordres.
Això és suficient perquè Claude 4.5 raoni de manera coherent. La memòria a llarg termini (registres de tasques, incrustacions) pot ser útil per a bases de codi recurrents, però tracteu-la com a sucre opcional. Si el teu agent no pot arreglar una prova sense un índex de vectors de 500 MB, no és un agent, és una dependència.
L'Esbós d'Implementació Mínima
En termes de pseudocodi, pots implementar aquest agent en un parell de centenars de línies:
- inicialitzar: carregar les metadades del repositori, les restriccions i el client del model
- observar: llegir les proves fallides, els fitxers, els registres
- 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)
Notaràs les parts que falten: cap agent que gestioni agents, cap “delegat”, cap “model de planificació” i “model d'executor” separat. Claude 4.5 pot fer bé les dues feines si no el sabotees amb un aparell de Rube Goldberg.
Prompting Que No S'Esforça Massa
Els prompts dolents intenten ser intel·ligents. Els prompts bons són avorrits i específics. Aquí teniu un esquelet sa per al vostre bloc d'instruccions central:
- Objectiu: Indiqueu la tasca de codificació exacta i els criteris d'èxit.
- Context: Estructura del projecte, punts d'entrada i ordre de prova.
- Restriccions: Llista blanca d'escriptura, límit de mida de diff, sense xarxa.
- Preferències d'estil: Versió d'idioma, formatador, regles de linter.
- Procés: Observar → Planificar → Actuar → Reflexionar; mostrar diffs; executar proves; iterar fins a N passos; aturar quan les proves passin.
Claude 4.5, amb aquesta estructura, no necessitarà un escenari de joc de rol de 100 línies. Simplement funciona.
Exemple Pràctic: Arreglar una Prova Fallida
Suposem que una prova falla a tests/time_test.py perquè parse_time("09:00") retorna 5400 en lloc de 32400. El bucle de l'agent hauria de semblar-se a això:
- Observar: Llegir time.py i time_test.py; executar pytest -k parse_time.
- Planificar: Hipòtesi: error de càlcul de segons vs minuts; proposar l'edició de parse_time; afegir un cas límit d'unitat.
- Actuar: Aplicar un pedaç a parse_time, afegir una prova per a les hores amb zero inicial; executar proves.
- Reflexionar: Si les proves encara fallen, llegiu l'error, ajusteu les matemàtiques o l'expressió regular, torneu a executar.
El pedaç mínim reeixit podria ser un canvi de dues línies. Aquest és el punt. Petites edicions, cicles ràpids, progrés real.
On Lleuger Supera la Pica de la Cuina
- Latència: Un model, un bucle, sense sobrecàrrega d'orquestració.
- Transparència: Cada pas és auditable. Pots diferenciar-lo, pots revertir-lo, pots tornar-lo a executar.
- Control: Els salvadors mantenen el dany local. L'agent no pot vagar per la teva infraestructura.
- Cost: Menys trucades, menys context, tokens predictibles.
- UX: Tu ho entens. Els teus companys d'equip ho entenen. El teu jo futur no t'odiarà.
I les contrapartides:
- Amplitud: Un agent de codificació lleuger no refactoritzarà el teu monorepositori de cinc idiomes en una sola passada. Ni tampoc hauria de fer-ho.
- Iniciativa: No inventarà fulls de ruta de diverses setmanes. Tu li dones tasques.
- Estat: Sense una gran capa de memòria, oblida la història distant per disseny. Això és una característica fins que és un error.
El Punt Dolç de Claude 4.5 per als Agents de Codificació
Claude 4.5 destaca en:
- Llegir i raonar sobre diffs i registres.
- Produir canvis de codi coherents i mínims.
- Seguir les restriccions i ser explícit sobre la incertesa.
És menys genial en:
- Endevinar el comportament de l'API que no pot llegir.
- Coreografia d'eines pesada (no necessària aquí).
- Refactors llargs de diversos fitxers sense que un humà guiï els passos.
Aquest últim punt és important. La millor manera d'obtenir resultats sòlids no és fer que l'agent sigui més gran, sinó fer que la tasca sigui més petita. Utilitza el teu cervell per a l'abast i Claude 4.5 per a l'execució dins d'aquest abast.
Una Paraula sobre la Integració de l'IDE
Resistiu la temptació d'incorporar això directament a un panell de l'IDE amb cinquanta interruptors. Un bucle basat en terminal amb diffs de text pla és més fàcil de confiar i depurar. Si vols sucre d'editor, mantén-lo ximple:
- Ordres per iniciar/aturar el bucle.
- Mostra els diffs en una vista dividida.
- Prompt d'aprovació per a les escriptures (opcional però prudent).
Pots integrar-ho més tard. Primer, fes que funcioni.
Sider.AI, Utilitzat amb Moderació, Ajuda Realment Si vols un entorn pragmàtic per executar aquest tipus de bucle sense reinventar l'encofrat, Sider.AISider realment funciona, almenys quan l'utilitzes per a allò en què és bo. Manté la conversa i els diffs ordenats, et permet executar ordres i no t'obliga a menjar un “marc d'agent autònom” grandiós. El truc és mantenir les teves pròpies regles: prompts curts, bucles ajustats, diffs visibles. Sider.AISider s'aparta del camí, cosa que és més rara del que hauria de ser. Dificultats Comunes (i Com Evitar Semblar Ximple)
- Context massa ple: Si el teu prompt sembla una nota de rescat, ho estàs fent malament. Obtingueu fitxers a la carta.
- Refactorització prematura: L'agent suggereix reorganitzar els mòduls? Fes que passi les proves primer. Refactoritza més tard.
- Fitxers al·lucinats: Exigeix list_dir i read_file abans de qualsevol write_file a una nova ruta.
- Bucles de re-execució infinits: Passos de límit. Exigeix justificació per a cada nova hipòtesi.
- Un diff gegant: Dividiu els canvis. Els diffs més petits fallen més ràpid i són més fàcils de raonar.
Seguretat i Protecció Sense Paranoia
- Execució local: Executar en un directori aïllat. Sense xarxa per defecte.
- Aïllament de dependències: Utilitzeu un venv local o un contenidor. Fixeu les versions.
- Secrets: L'agent no els necessita. Si una ordre exigeix un token, atura't i pregunta.
- Auditoria: Persistiu cada pla, diff i ordre en un registre.
Com Saber que Està Funcionant
- La reducció del temps de lliurament: Les correccions d'errors que abans trigaven una hora ara triguen deu minuts.
- Menys errors de dit gras: Els diffs es fan més petits, les proves es tornen més verdes.
- Hi confies: Deixes de passar per sobre de cada acció perquè no t'ha cremat.
- Els companys d'equip l'utilitzen: La definició d'èxit és que altres l'adoptin sense una reunió.
Ampliar, Amb Cura
Si realment has d'ampliar, fes-ho amb disciplina:
- Subtasques paral·leles, no cervells paral·lels: Dividiu el treball, executeu diversos bucles lleugers en directoris separats i combineu quan estigui verd.
- Memòria episòdica, no un abocador cerebral: Emmagatzemeu els pedaços reeixits i els mapatges de símptomes a solucions. Recupereu quirúrgicament.
- Passades periòdiques “més grans”: Reserveu una sessió guiada per humans per a refactoritzacions; l'agent ajuda, no lidera.
Una Implementació de Referència Mínima (Esbós)
Pseudocodi semblant a Python per posar-se en marxa:
- 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)})
Un Final de Mida Humana
La indústria continua prometent agents desenvolupadors autònoms. El que realment necessitem és un assistent honest que llegeixi, planifiqui, editi, executi i s'aturi. Claude 4.5 és bo en això, sempre que no l'enterreu sota marcs que existeixen principalment per justificar-se. Lleuger no és un compromís, és el punt. Construïu el bucle, afegiu els salvadors i deixeu que l'eina faci l'única cosa que les eines sempre han fet quan les manteniu simples: fer que la feina sigui més petita.
Conclusió: La Drecera Avorrida Que Guanya
Aquí teniu la vostra llista de verificació per a un agent de codificació lleuger amb Claude 4.5:
- Un bucle, un model, eines petites.
- Context ajustat: tasca, uns quants fitxers, les últimes sortides.
- Diffs mínims, proves freqüents, límits estrictes.
- Execució local i aïllada; sense xarxa.
- Sucre d'editor opcional; mai obligatori.
Si mires amb els ulls entretancats, sembla sospitosament una bona enginyeria de programari, només que més ràpida. I aquesta és la frase final. El més intel·ligent que pots fer aquí no és perseguir l'“autonomia”, sinó codificar la disciplina. Com menys demanis a l'agent, més obtens.
Preguntes Freqüents
Q1:Com començo a construir un agent de codificació lleuger amb Claude 4.5?
Definiu un conjunt d'eines petit (llegir, escriure, cercar, executar), escriviu un prompt de sistema estricte i implementeu un bucle Observar → Planificar → Actuar → Reflexionar. Manteniu el context petit i alimenteu registres i diffs reals; Claude 4.5 funciona millor quan la tasca és estreta i els comentaris són concrets.
Q2:Necessito una base de dades de vectors o una capa de memòria per a un agent de codificació Claude 4.5?
No. Per a la majoria de les tasques, la memòria a curt termini més search_code és suficient. Afegiu memòria a llarg termini només si revisiteu repetidament el mateix repositori i podeu demostrar que estalvia tokens sense fer que l'agent sigui més ximple.
Q3:Quins salvadors són essencials per a un agent de codificació Claude 4.5?
Llista blanca de rutes editables, limiteu les mides de diff, restringiu les ordres i registreu cada acció. Aquests límits senzills mantenen l'agent predictible i fan que les reversions siguin avorrides, d'una bona manera.
Q4:Pot un agent lleuger gestionar refactoritzacions de diversos fitxers?
Sí, si dividiu el treball en petits passos i manteniu el bucle ajustat. Claude 4.5 pot gestionar refactoritzacions, però vosaltres guieu l'abast; en cas contrari, obtindreu un diff gegant i fràgil que no voldreu revisar.
Q5:On encaixa Sider.AI amb un agent de codificació Claude 4.5?
Sider.AI és útil com a espai de treball ordenat: converses, diffs i ordres en un sol lloc, sense forçar un marc d'agent pesat. Utilitzeu-lo per executar el vostre bucle, no per reinventar-lo. 
