Alguna vegada has desitjat que el teu codi es pogués escriure sol?
Coneixes aquell moment en què mires la pantalla, murmures "simplement fes la crida a l'API", i l'ordinador et torna la mirada com un gat a qui has demanat que faci els impostos? És aquí on els assistents de codificació d'IA entren ballant amb capes. L'estrella d'avui: Claude. I no el poeta filosòfic del segle XIX, sinó el model d'IA que converteix les teves indicacions en codi que funciona, amb una manera de fer que és estranyament pacient.
Vaig passar una setmana donant ordres a Claude com un ajudant de cuina molt educat. "Claude, talla aquest JSON." "Claude, fregeix aquest SQL." "Claude, no cremis les proves unitàries." Al final, vaig aprendre una veritat senzilla: obtenir grans resultats de Claude Code depèn menys de la màgia i més de com li parles. Com un gran becari, prospera amb instruccions clares, exemples i un pla.
Aquesta és la teva guia amigable, lleugerament cafeïnada, de consells de Claude Code: des de la indicació fins a l'execució del codi, perquè la teva propera sessió acabi amb una aplicació en execució, no amb un atac de còlera.
Què és Claude i per què t'hauria d'importar?
Claude és un model d'IA d'Anthropic que és particularment bo per llegir, raonar i generar text, incloent-hi codi. Pensa en ell com un copilot acurat i conscient que està content d'escriure funcions, explicar el teu rastre d'error com un conte abans d'anar a dormir, i fins i tot refactoritzar els teus espaguetis en linguine.
On destaca:
- Convertir indicacions en anglès senzill en fragments de codi en llenguatges com Python, JavaScript/TypeScript, Go i més.
- Raonar sobre casos límit i proves si li ho demanes de la manera correcta.
- Llegir grans fragments del teu repositori (dins dels límits de context) i resumir el desastre.
On necessita un petit impuls:
- Les indicacions vagues condueixen a codi vague. (No és psíquic; és educat.)
- Si no especifiques les versions de l'entorn d'execució o del framework, podria "recordar" els valors per defecte incorrectes.
- Pot sonar segur quan està endevinant, així que encara provaràs, analitzaràs i executaràs localment com un enginyer adult.
La indicació que imprimeix diners (bé, codi que funciona)
Aquí teniu la recepta a la qual vaig tornar contínuament. És el meu entrepà d'indicació de Claude Code: context, restriccions i comprovacions.
- Context: què estàs construint, l'entorn i qualsevol codi existent.
- Restriccions: llenguatge, versions, frameworks, objectius de rendiment o llegibilitat.
- Comprovacions: com validarem l'èxit: proves, registres o exemples d'entrades/sortides.
Una plantilla que pots robar:
"Rol: Ets un enginyer sènior acurat.
Objectiu: Construir X que faci Y.
Entorn: Node 20, Express 4, PostgreSQL 15. S'executa a Render. Utilitza TypeScript.
Interfícies: Aquí teniu un exemple de sol·licitud/resposta.
Restriccions: Prefereix la biblioteca estàndard. Evita les dependències externes tret que sigui necessari.
Lliuraments:
- Una instrucció d'execució d'una sola comanda
Validació: Proporcioneu un exemple d'entrada/sortida que pugui enganxar per verificar."
Ara mira com això converteix un miserable "construeix una API" en una llista de verificació de cirurgià.
De la indicació a l'execució del codi: un tutorial pràctic
Suposem que vols un petit servei que converteixi Markdown a HTML amb un toc de sanejament. Això és el que passa quan apliques l'entrepà d'indicació.
Indicació (abreujada):
"Construeix un endpoint POST /render a Node 20 + Express 4 (TypeScript). Entrada: { markdown: string }. Sortida: { html: string }. Evita dependències pesades; saneja les etiquetes bàsiques; inclou proves Jest; proporciona una sola comanda per executar; mostra exemples de curl."
Què retorna Claude quan ets clar:
- Un servidor Express ordenat amb configuració de TypeScript
- Un sanejador minimalista (o una dependència cautelosa amb justificació)
- Proves Jest que cobreixen entrada buida, entrada llarga i etiquetes gamberres
- Comandes Curl com:
curl -X POST -H "Content-Type: application/json" -d '{"markdown":"# Hello "}'
Consell d'expert: demana comentaris al codi que expliquin per què existeix cada pas. Això sol pot estalviar-te deu minuts d'estrènyer els ulls i un missatge de Slack al teu Jo del futur.
Consells de Claude Code que realment fan avançar les coses
1) Especifica les versions com si estiguessis empaquetant per a un viatge d'acampada
- Dolent: "Fes una aplicació Flask."
- Bo: "Fes una aplicació Flask (Python 3.11, Flask 3.0), executa-la mitjançant
flask run, sense estat global, utilitza pip-tools per a les dependències."
Per què? Els frameworks canvien, i Claude en sap molt, però no és omniscient sobre la teva màquina. La claredat de la versió evita aquells moments de "funciona al meu portàtil del 2022".
2) Proporciona una petita especificació amb exemples
"Donada aquesta entrada, espero exactament aquesta sortida." Inclou almenys:
- Un cas límit (buit, nul, límit de frontera)
- Un cas dolent (tipus no vàlid, càrrega útil maliciosa)
Claude reflectirà la teva minuciositat. Si li dónes un regle, mesura amb precisió.
3) Demana proves per endavant, no com a postres
Quan dius: "Escriu proves Jest que fallin si fem una regressió", estàs preinstal·lant un cinturó de seguretat. Claude pot generar proves que serveixin també de documentació, i sovint detectaran les seves pròpies importacions al·lucinades.
4) Exigeix una secció d'execució/verificació
Les grans indicacions acaben amb: "Inclou instruccions d'execució pas a pas i una comanda de verificació que pugui enganxar." El teu jo futur t'ho agrairà quan les peculiaritats de Docker, Poetry o Node treguin el cap.
5) Mostra el teu codi existent, però retalla'l
Enganxar tot el repositori és com donar a algú la Biblioteca del Congrés quan va demanar una recepta. Proporciona només els fitxers rellevants (a més del package.json o pyproject que afecti les importacions). Demana a Claude que suggereixi refactoritzacions només als fitxers que enumeris: els elements de protecció ajuden.
6) Pensa en diferències
Si estàs modificant codi, pregunta: "Retorna un pegat de diferència unificada per als fitxers X i Y, sense comentaris als blocs de codi, i una explicació separada després." Es converteix en amigable per copiar i enganxar, i evita aquella barreja de "on poso això?".
7) Fes que s'expliqui en anglès senzill
"Abans del codi, descriu l'enfocament en 5 punts. Després del codi, explica les contrapartides." Quan Claude articula un pla, pots dirigir-lo abans que escrigui 300 línies en la direcció equivocada.
8) Estableix elements de protecció contra l'excés de zel
"No afegeixis dependències de tercers tret que ho aprovi. Si creus que en necessitem una, proposa dues opcions amb pros i contres." Ara tu ets l'arquitecte, no el passatger passiu.
9) Empenta'l cap a la seguretat i el rendiment
Afegeix indicacions com:
- "Valida totes les entrades; rebutja càrregues útils de >1 MB."
- "Escapa la sortida; assumeix entrades hostils."
- "Objectius de Big-O: O(n log n) o millor per al camí principal."
- "Registra només metadades segures i no PII."
Claude estarà a l'altura de les circumstàncies (o almenys farà preguntes intel·ligents).
10) Dóna-li una personalitat: útil, no bonica
"Sigues concís, fes preguntes aclaridores abans de codificar i evita l'especulació." És sorprenent la freqüència amb què aquesta única frase redueix les desviacions a la meitat.
Una història de dues indicacions
- La indicació difusa: "Fes un script que netegi els meus CSV."\nResultat: Un script que neteja un CSV (singular), assumeix comes, s'ennuega amb punt i coma i oblida Unicode com si fos el 1999.
- L'especial de Claude Code: "Crea un script de Python 3.11
clean_csv.py que:
- Accepta camins de fitxers d'entrada i sortida com a arguments de CLI
- Detecta delimitadors (coma/punt i coma/tabulació)
- Normalitza les capçaleres a snake_case
- Elimina BOM i retalla espais en blanc
- Conserva la citació; gestiona UTF-8
- Inclou proves
pytest amb 3 accessoris d'exemple
- Proporciona un objectiu
Makefile make test i make run."
Aquest segon gairebé s'instal·la sol.
Executar el codi: la teva llista de verificació de cinc minuts sense drama
Tens el codi de Claude. I ara què? Aquí teniu un petit ritual que aixafa el 80% del drama de "no s'executa".
- Si és Node: suprimeix node_modules, executa
npm ci (o pnpm i --frozen-lockfile). Si és Python: nou virtualenv + pip install -r requirements.txt (o Poetry). Si és Go: go mod tidy.
- Executa ESLint/Prettier o Black/Ruff. Demana a Claude que afegeixi configuracions si falten. Un format consistent evita les diferències "fantasma".
- Executa proves abans que l'aplicació. Si fallen, copia els errors a Claude i digues: "Diagnostica i proposa diferències mínimes".
- Utilitza la comanda d'inici exacta que va subministrar Claude. Si ho ha oblidat, digues-li que n'afegeixi una.
- Comprovació de la cordura
- Enganxa l'exemple de curl o l'entrada de CLI. Confirma que les sortides coincideixen amb l'especificació. Si no és així, enganxa la discrepància i demana a Claude que reconciliï l'especificació amb el codi.
- Mantén els canvis petits. Demana diferències. Torna a executar les proves. Repeteix. És com rentar-se les dents: poc glamurós, però salva vides.
El ball de la depuració: com tornar els errors a Claude
Claude està en el seu millor moment quan el tractes com un programador de parelles amb ulls però sense mans al teclat.
- Enganxa l'error exacte, inclòs el rastre de la pila i els números de línia.
- Inclou el fragment del fitxer que falla (20–40 línies al voltant del problema).
- Indica què has provat: "Vaig executar X; esperava Y; vaig obtenir Z."
- Demana la correcció més petita: "Proposa un pegat de diferència mínima".
Bonificació: Digues-li el teu sistema operatiu i shell. Molts errors "misteriosos" són realment camins de Windows vs. POSIX, o escapament de zsh.
Claude vs. realitat: tres sots comuns (i correccions)
- Importacions al·lucinades
- Símptoma: "ModuleNotFoundError" per a una biblioteca que mai has instal·lat.
- Solució: "No assumeixis biblioteques que no figuren a package.json/requirements.txt. Si sembla que cal una dependència, proposa opcions amb pros i contres i demana aprovació."
- Símptoma: Codi dirigit a les API d'Express 5 que encara no estàs utilitzant.
- Solució: "Utilitza només les API d'Express 4.18; si necessites funcions 5.x, explica la solució alternativa."
- Símptoma: Dues fàbriques, un patró de visitant i una crisi d'identitat menor per a una funció que imprimeix 'Hola'.
- Solució: "Afavoreix la biblioteca estàndard; minimitza les abstraccions; mantén les funcions per sota de 50 línies tret que estigui justificat; busca la llegibilitat per sobre de l'intel·ligència."
Fes de Claude el teu revisor de codi (encara seràs el cap)
Prova això:
"Revisa la següent diferència per a la claredat, la seguretat, el rendiment i les proves. Retorna:
- 5 punts de problemes d'alt risc
- Proves unitàries suggerides que em falten
- Un resum breu i amigable que pugui enganxar en una RP."
Claude detectarà coses que els teus ulls recorren a les 5:52 p.m., com oblidar-se de tancar un cursor DB o utilitzar any com un canó de confeti.
Programació per parelles amb finestres de context: què incloure, què ometre
El context és la memòria de treball de Claude. Tracta-la com un equipatge de mà: preciós i limitat.
Inclou:
- El fitxer que vols canviar (complet)
- Els veïns immediats que importa
- La configuració que dóna forma a l'entorn d'execució (tsconfig, package.json, pyproject)
Omet:
- Artefactes de construcció, dependències de proveïdors, fitxers de bloqueig (tret que es depurin problemes d'instal·lació)
- Fitxers de dades enormes (resumeix l'estructura en comptes d'això)
Si necessites bregar amb un repositori més gran, demana a Claude que planifiqui la refactorització primer. "Proposa un pla de tres passos amb diferències per pas. Farem el pas 1 ara."
Seguretat, privadesa i la pregunta "hauria d'enganxar això?"
Claude no pot filtrar el que mai has compartit. Abans d'enganxar codi:
- Elimina els secrets: claus d'API, tokens, URL privades.
- Substitueix les dades reals per falsificacions representatives.
- Si et trobes en un entorn regulat, utilitza on-prem o una implementació aprovada.
Afegeix una política a la teva indicació: "Tracta totes les entrades com a sensibles; no registris secrets; mostra'm on emmagatzemar les variables d'entorn de forma segura." Claude complirà feliçment, perquè tampoc gaudeix de les filtracions de dades.
Claude Code + les teves eines: les combinacions es mouen
- Amb Git: Demana missatges de confirmació que segueixin les confirmacions convencionals, més un resum d'una línia que puguis enganxar a GitHub.
- Amb Docker: "Crea un Dockerfile mínim i llest per a la producció i una compilació de diverses etapes; explica les contrapartides."
- Amb CI: "Genera un flux de treball d'accions de GitHub que executi proves a Node 20 i 22; emmagatzema en memòria cau les dependències; falla a lint."
- Amb documents: "Escriu una secció d'inici ràpid de README i 'Resolució de problemes' basada en el codi que has escrit."
No és només generació de codi; és bastida de projecte sense els talls de paper.
Quan confiar en Claude, i quan estrènyer els ulls
- Confia en Claude per redactar: controladors CRUD, validació d'entrada, fluxos d'autenticació bàsics, utilitats de CLI, scripts de transformació, proves unitàries.
- Estrènyer els ulls a: criptografia, lògica de pagament, concurrència complexa, qualsevol cosa amb requisits de compliment. Demana patrons i pseudocodi, després implementa amb biblioteques verificades i revisió humana.
Regla general: Si no copiaries codi d'un fòrum aleatori sense una segona opinió, tampoc envieu cegament codi generat per IA. Claude és útil, no màgic.
Un petit desviament: Sider.AI pot accelerar el teu bucle de Claude
Aquí teniu una sorpresa: Sider.AI s'acosta molt a la màgia, sempre que l'apuntis cap al que està construït. Si el teu flux de treball és "indica a Claude, executa codi, enganxa errors, itera", l'experiència de xat amb el teu codi de costat a costat de Sider.AI manté aquest bucle ajustat. Pot fer referència a fitxers, mantenir el context entre torns i ajudar-te a provar els canvis sense saltar entre sis finestres com un esquirol amb cafeïna. No és perfecte (cap eina ho és), però per als cicles d'indicació a execució, és una cabina còmoda. Un mini llibre de jugades: cinc indicacions que reutilitzaràs setmanalment
"Crea un servei Node 20 + Express 4 TypeScript amb un POST /health i GET /version. Inclou tsconfig, eslint, jest, scripts npm per a build/test/start, Dockerfile i accions de GitHub. Proporciona una comanda curl per verificar."
- Refactoritza per a la llegibilitat
"Refactoritza la funció següent per a la claredat i la provabilitat. Mantén el comportament idèntic. Afegeix 3 proves unitàries que capturin casos límit. Explica cada canvi en una frase."
- Esquema de base de dades + migracions
"Dissenya un esquema de PostgreSQL 15 per a una aplicació de notes: usuaris, notes, etiquetes, note_tags. Proporciona instruccions CREATE TABLE, índexs, un script de migració i una llavor d'exemple. Justifica els índexs amb patrons de consulta esperats."
"Donada aquesta funció lenta i la seva sortida de profiler, proposa un enfocament més ràpid. Objectiu d'augment de velocitat de 2x. Proporciona un arnés de referència i explica les contrapartides."
- Enduriment de la producció
"Afegeix validació d'entrada, limitació de velocitat i registre de sol·licituds a aquesta API. Mantén les dependències mínimes. Mostra valors per defecte segurs, configuració mitjançant variables d'entorn i proves que confirmin el comportament de limitació de velocitat."
Copia, enganxa, esbandeix, envia.
Barra lateral de resolució de problemes: quan Claude surt dels rails
- Símptoma: Reescriptura tot el teu fitxer quan vas demanar una línia.\nSolució: "Retorna una diferència unificada mínima només amb les línies canviades. Sense comentaris afegits dins del bloc de codi."
- Símptoma: Continua triant el patró de framework incorrecte.\nSolució: "Segueix l'estil existent del fitxer. No converteixis a classes/ganxos/asíncron tret que ho demani."
- Símptoma: Ignora les teves proves.\nSolució: "Fes de les proves la font de la veritat; alinea el codi per satisfer-les. Si les proves entren en conflicte amb l'especificació, proposa com reconciliar-les."
- Símptoma: Utilitza dependències no aprovades.\nSolució: "Atingue't a la biblioteca estàndard. Si una dependència és essencial, atura't i demana aprovació amb dues alternatives."
Una paraula amable sobre la documentació
Demana a Claude que generi:
- Un inici ràpid que reflecteixi les ordres reals del teu repositori
- Una secció de resolució de problemes extreta de les teves fallades de prova
- Un glossari que tradueixi les sigles a l'anglès
- Docstrings en línia que expliquin per què, no només què
Els documents no són postres; són el plat. T'adones quan falta.
La llista de verificació de 10 segons abans d'enviar
- Les proves passen localment i a CI?
- Les dependències estan fixades i són mínimes?
- Has escanejat per a secrets a l'historial del repositori?
- Els missatges d'error són útils (acció + suggeriment) i no filtren detalls interns?
- Hi ha un pla de reversió o una bandera de característica?
Si no pots respondre que sí a aquestes preguntes, demana a Claude que t'ajudi a omplir els buits. És sorprenentment bo per escriure les coses que tendim a procrastinar.
En resum: tu parles, Claude construeix, i tu et mantens al càrrec
Claude Code pot sentir-se com contractar un desenvolupador junior brillant que mai dorm i mai resenteix les teves crítiques. Quan ets específic sobre les versions, els exemples, les restriccions i com provaràs, el codi que escriu tendeix a executar-se al primer intent. Quan tornes a fer un bucle als errors amb rebuts (un rastre de la pila, un fragment, l'esperat vs. el real), converteixes "IA endevinant" en "IA col·laborant".
Així que la recepta és senzilla: indicacions clares, elements de protecció sensibles, proves primer, bucles petits. Afegeix un pessic d'escepticisme i un costat de Sider.AI per accelerar el ball, i passaràs de la indicació a l'execució del codi amb molt poques llàgrimes. Bé, tret que el teu linter estigui configurat com a "estricte". En aquest cas... potser una llàgrima. Una última cosa: desa les teves millors indicacions en un fitxer just al teu repositori: /prompts/claude.md. D'aquesta manera, cada nou company d'equip obté un avantatge, inclosa la IA. El teu jo futur donarà una mà al teu jo passat, i el teu jo present finalment podrà anar a dinar.
FAQ
P1: Quins són els millors consells per a Claude Code per obtenir codi que funcioni ràpidament?
Sigues específic sobre les versions, proporciona exemples d'entrada/sortida i demana proves i instruccions d'execució per endavant. Tracta Claude com un copilot acurat: petites diferències, enganxa errors exactes i itera. Aquests consells de Claude Code redueixen les conjectures i t'acceleren des del prompt fins a l'execució del codi.
P2: Com executo i verifico el codi que genera Claude?
Instal·la les dependències de manera neta, executa lint/proves i, a continuació, utilitza l'ordre d'inici exacta i fes un sample curl al prompt sol·licitat. Si la sortida no coincideix amb l'especificació, enganxa la no coincidència de nou a Claude i demana una diferència mínima per solucionar-ho. Els passos de validació clars converteixen el codi de Claude en aplicacions en execució de manera fiable.
P3: Com puc evitar que Claude afegeixi dependències aleatòries?
Indica la regla al teu prompt: només la biblioteca estàndard tret que s'aprovi. Si una dependència sembla necessària, demana a Claude que faci una pausa i proposi dues opcions amb avantatges i contres. Aquesta protecció manté el codi de Claude lleuger i evita les importacions sorpresa.
P4: Pot Claude ajudar també amb la depuració i les proves?
Absolutament: enganxa traces de pila, proves fallides i la part de codi rellevant, i demana un patch mínim. Claude és excel·lent per generar proves unitàries que documenten el comportament i eviten regressions, cosa que fa que el teu bucle de prompt a execució sigui molt més fluid.
P5: És útil Sider.AI juntament amb Claude per als fluxos de treball de codi?
Sí, la configuració de xat paral·lel amb el teu codi de Sider.AI manté el context a mà i redueix el canvi d'eines. No és una solució màgica, però per als consells de Claude Code i els bucles d'execució de prompt a codi, és una manera còmoda d'iterar més ràpidament sense perdre el fil. 
