Claude Code în terminal: 7 upgrade-uri de flux de lucru pentru power users

Claude Code, în versiunea sa de bază, este deja util imediat după instalare. Îl instalați, îl ghidați cu un prompt și construiește ce aveți nevoie. Pentru majoritatea, acesta este setup-ul de „vibe-coding” și funcționează.

Versiunea pe care o folosește cineva cu un terminal personalizat este însă un alt instrument. Au preaprobat comenzile bash în care au încredere, așa că Claude aproape niciodată nu mai cere permisiiuni. Un CLAUDE.md stă în rădăcina proiectului, astfel încât Claude cunoaște deja convențiile din momentul în care se deschide sesiunea. Iar când o sesiune începe să pară confuză, comanda la care apelează nu este un restart.

Acest articol umple golul dintre cele două setup-uri Claude Code, în șapte upgrade-uri. Niciunul nu durează mai mult de zece minute de configurat, iar fiecare se amortizează într-o săptămână.

Dacă nu ați deschis niciodată Claude Code, ghidul nostru principal pentru Claude Code este un punct de pornire mai bun. Tot ce urmează presupune că deja puteți crea prompturi și accepta apeluri de tool-uri.

1. Nu mai reaprobați aceleași comenzi

Implicit, fiecare nouă invocare de instrument vă cere aprobare. Acceptabil prima dată când rulați pytest. Enervant a treia oară. A zecea oară, apăsați Enter fără să citiți promptul. Este cel mai rău dintre ambele lumi: v-ați antrenat să ignorați verificarea de siguranță, iar ea tot vă încetinește.

Desigur, există modul „dangerously bypass permissions” sau „auto mode”. I-am discutat pe larg compromisurile în tutorialul meu despre Auto Mode și Canale în Claude Code.

Definirea permisiunilor în fișierul settings.json

Soluția este un fișier .claude/settings.json în rădăcina proiectului, cu un bloc permissions care preaprobă modelele în care aveți încredere și blochează ceea ce nu doriți:

{
  "permissions": {
	"allow": [
  	"Bash(pytest *)",
  	"Bash(uv run *)",
  	"Bash(ruff check *)",
  	"Read(~/.zshrc)"
	],
	"deny": [
  	"Bash(curl *)",
  	"Read(./.env)",
  	"Read(./.env.*)",
  	"Read(./secrets/**)"
	]
  }
}

Regulile se evaluează într-o ordine fixă: mai întâi deny, apoi ask, apoi allow. Prima potrivire câștigă, deci o regulă de deny învinge întotdeauna o regulă allow ulterioară.

Stăpâniți aria de aplicare și wildcard-urile

Trei lucruri îi încurcă pe oameni prima dată când scriu așa ceva.

1. Primul este aria de aplicare (scope). Un .claude/settings.json la nivel de proiect suprascrie fișierul global ~/.claude/settings.json, deci dacă ați permis Bash(rm *) la nivel global, iar un proiect îl neagă, proiectul are prioritate. Este comportamentul corect, dar îi surprinde pe cei care se așteaptă ca permisiunile globale să fie „bătute în cuie”.

2. Al doilea sunt wildcard-urile pe comenzile de rețea. Bash(curl http://github.com/ *) pare restrictiv, dar nu acoperă https://, opțiuni înainte de URL, redirecționări sau expansiunea de variabile shell. Modelul recomandat în documentație este să negați Bash(curl *) complet. Apoi folosiți instrumentul WebFetch cu WebFetch(domain:github.com) pentru domeniile pe care chiar vreți să le permiteți.

3. Al treilea este spațiul alb. Bash(ls *) se potrivește cu ls -la dar nu cu lsof. Bash(ls*) le potrivește pe ambele. Spațiul înainte de asterisc chiar contează, așa că merită să fiți deliberat cu ce ați scris.

Câteva keybinding-uri stau alături de permisiuni în aceeași categorie „nu te mai lupta cu terminalul” și merită învățate din prima zi:

• Shift+Tab schimbă ciclul modurilor de permisiune (implicit, auto-accept, plan)

• Esc+Esc deschide selectorul de „rewind” (mai multe la #3)

• Ctrl+R caută invers în istoricul prompturilor, la fel ca în bash și zsh

• Ctrl+U șterge de la cursor până la începutul liniei

• Shift+Enter adaugă o linie nouă în interiorul promptului

Majoritatea acestor keybinding-uri funcționează din start în terminale. Dacă nu, rulați o dată comanda cu slash /terminal-setup pentru a instala totul.

2. Faceți-l pe Claude Code să-și amintească proiectul

Fiecare sesiune începe cu o fereastră de context proaspătă.

Implicit, Claude nu-și amintește că folosiți uv în loc de pip. Nu-și amintește că testele sunt în tests/ și nu în test/. Iar convențiile de API pe care le-ați explicat în zece ture ieri au dispărut. Soluția este un fișier CLAUDE.md la rădăcina proiectului. Lansați Claude Code din acel director (sau din orice subdirector) și fișierul este încărcat automat în context înainte de primul prompt.

Cea mai rapidă metodă de pornire este /init. Rulați-o în interiorul proiectului. Claude citește codul și scrie un CLAUDE.md de pornire, cu comenzile de build, instrucțiunile de test și convențiile pe care le poate deduce. Îl veți edita după aceea, deoarece /init vă oferă o bază funcțională, nu un fișier finalizat.

Există trei locuri unde Claude caută context, suprapuse:

CLAUDE.md de proiect la ./CLAUDE.md merge odată cu repo-ul. Este același pentru fiecare contributor, deci puneți aici detaliile specifice proiectului:

• Managerul de pachete și versiunea limbajului
• Comanda de test și unde se află testele
• Structura directoarelor și convențiile mai puțin evidente
• Orice ar trebui să știe un coleg nou din prima zi

CLAUDE.md de utilizator la ~/.claude/CLAUDE.md vă urmărește în toate proiectele de pe mașina dumneavoastră. Aici se pun preferințele personale: stilul de cod, cum preferați docstring-urile, limbajele pe care le alegeți prima dată. Nu puneți fapte specifice proiectului aici, pentru că se vor „scurge” în orice alt repo pe care îl deschideți.

Memoria automată este al treilea strat și este scrisă de Claude. Când îl corectați în timpul unei sesiuni („aici folosim snake_case, nu camelCase”), corecția este înregistrată în ~/.claude/projects/<project>/memory/MEMORY.md. Primele 200 de linii sau 25KB din acel fișier se încarcă la începutul fiecărei conversații din același proiect. Puteți vedea ce se încarcă cu /memory, care vă permite și să activați/dezactivați memoria automată.

O regulă de dimensionare: păstrați fiecare CLAUDE.md sub 200 de linii. Dincolo de atât, fișierul începe să consume context semnificativ la fiecare tură, iar Claude urmează fișierele lungi mai puțin fiabil decât pe cele scurte. Dacă al dumneavoastră depășește, împărțiți-l în .claude/rules/ cu scope-uri pe căi. Pentru o analiză mai detaliată a ceea ce ar trebui să intre într-un fișier CLAUDE.md, vedeți ghidul meu despre cum să scrieți cel mai bun CLAUDE.md.

3. Nu mai reporniți sesiunile când o iau razna

Reflexul, când o sesiune începe să pară „dusă”, este să rulați /clear și să o luați de la capăt. De cele mai multe ori, este reflexul greșit. Repornirea aruncă la gunoi căile de fișiere pe care le edita Claude, testul eșuat pe care îl urmărea sau constrângerile pe care le-ați stabilit la început. O sesiune nouă trebuie să reînvețe totul, iar plătiți reînvățarea în tokeni și timp.

Primul lucru de învățat este simptomul. O astfel de „putrezire” a contextului are câteva semnale evidente:

• Claude cere din nou o cale de fișier pe care a editat-o acum cinci ture
• Repetă o sugestie pe care deja ați respins-o
• Pierde urma branch-ului pe care vă aflați
• L-ați corectat de mai mult de două ori pe același punct în aceeași sesiune

Odată ce le vedeți, aveți patru opțiuni, și nu sunt interschimabile:

Compactarea sesiunii

 /compact nu e atât de rău pe cât susțin unii utilizatori.

CLAUDE.md-ul de proiect supraviețuiește. Claude recitește fișierul de pe disc după compactare și îl re-injectează, astfel încât convențiile nu se pierd. Puteți, de asemenea, să treceți instrucțiuni de focalizare pentru a ghida rezumatul, de tipul /compact păstrează deciziile de refactor pentru auth, elimină rulările de teste eșuate. Aceasta e diferența dintre un rezumat util și unul generic.

Folosirea opțiunii „undo” din Claude Code

Selectorul de „rewind” pe Esc+Esc este acel lucru despre care cei mai mulți nu știu că există. Deschide o listă cu fiecare checkpoint de prompt din sesiune. După ce alegeți unul, oferă trei opțiuni: restaurează doar conversația, doar codul sau ambele.

„Restore code and conversation” este ce își doresc cei mai mulți. O jumătate de oră de ture proaste pot dispărea fără să deschideți git. Este cel mai apropiat lucru pe care îl are Claude Code de un „undo” pentru o sesiune întreagă.

După ce nu mai reporniți, problema următoare este regăsirea sesiunilor.

Denumiți și redeschideți sesiunile

claude -n <name> (sau --name) pornește o sesiune denumită, iar numele apare în /resume și în titlul terminalului. Când aveți trei lucruri în curs în același repo (un branch de experiment, un refactor, o sesiune de debug), numele sunt modul în care le deosebiți. /rename schimbă numele în timpul sesiunii dacă vi se schimbă aria.

Sfat: Folosiți /color pentru a distinge și mai bine sesiunile când rulați mai multe în aceeași fereastră de terminal.

Redeschiderea unei sesiuni se face prin două flag-uri. claude --continue (sau -c) încarcă cea mai recentă conversație din directorul curent. Folosiți-l când tocmai ați fost aici și vreți să continuați.

claude --resume deschide un selector interactiv, iar claude --resume <name-or-id> sare direct la o sesiune specifică. Tratați sesiunile ca pe branch-urile git: fluxuri de lucru diferite merită propriile sesiuni.

4. Planificați lucrurile grele, economisiți la cele ușoare

Cel mai mare cost într-un setup personalizat nu e editorul sau keybinding-urile. E potrivirea cantității de compute pe care o consumați cu dificultatea sarcinii din față. Trei instrumente lucrează împreună pentru asta: plan mode, /effort și /model.

Folosirea plan mode în Claude Code

Plan mode îi spune lui Claude să gândească un demers înainte să atingă fișierele. Scrie planul, dumneavoastră îl citiți, îl aprobați sau îl corectați, și abia apoi execută.

Un truc pe care îl folosesc pentru a-mi face planurile solide este un prompt simplu pe care îl folosesc des:

Red-team this plan from multiple angles using as many Opus 4.7 agents as you need.

Acesta va lansa mai mulți subagenți pentru a revizui planul din mai multe perspective și a sugera remedieri. Este o practică bună când lucrați cu un fișier de plan cu peste 500 de linii.

Costul este că planificarea plus red-teaming adaugă două ture înainte ca orice cod să ajungă, așa că pentru orice mai puțin decât o funcționalitate semnificativă sau un bug fix important, este prea mult.

Există cinci moduri de a intra în plan mode:

Forma inlină (/plan refactorizează modulul de auth să folosească JWT) este cea pe care cei mai mulți o ratează. Setează modul și sarcina dintr-o singură mișcare, nu din două. Pentru un ghid mai detaliat al fluxurilor „review-first” în plan mode, tutorialul meu despre plan mode în Claude Code merge pas cu pas.

Setarea unui nivel adecvat de efort

Următorul lucru de învățat este Effort. Controlează cât „gândit extins” face Claude la fiecare tură. Efort mai mare înseamnă raționament mai profund, mai mulți tokeni și răspuns mai lent.

/effort <level> și flag-ul CLI --effort <level> acceptă toate cele cinci valori. Low, medium, high și xhigh persistă între sesiuni. Max este doar pe sesiunea curentă pentru că elimină constrângerea de cheltuire a tokenilor, deci îl setați intenționat de fiecare dată. Implicitul potrivit pentru munca zilnică este low sau medium. Rezervați high sau xhigh pentru probleme cu adevărat dificile, iar max pentru momentele când preferați să ardeți tokeni decât să greșiți.

Un contraargument de ținut minte: un model pe low cu un context excelent bate adesea același model pe max cu un context slab. Curățarea promptului este de obicei un câștig mai mare decât creșterea efortului.

Alegerea modelului potrivit

Selecția modelului este locul unde apar economiile reale. /model permite comutarea în timpul sesiunii, iar Option+P (macOS) / Alt+P (Win/Linux) schimbă modelul fără a goli ce ați tastat deja. Aliasurile utile:

• sonnet este implicitul pentru folosirea zilnică

• opus este pentru cele mai dificile probleme (aliasul best rezolvă tot către opus)

• haiku este pentru când vreți viteză

• sonnet[1m] și opus[1m] sunt variantele cu context 1M

• opusplan rulează Opus în plan mode și Sonnet la execuție

• default elimină suprascrierea și revine la modelul recomandat

Dacă folosiți implicit Opus pentru orice, trecerea la Sonnet pentru cea mai mare parte a zilei este cea mai mare reducere de cheltuială disponibilă.

Opus este alegerea corectă când sunteți blocat pe ceva dificil și vreți cel mai inteligent model. Sonnet gestionează aproape tot restul. Diferența de cost dintre ele este suficient de mare încât „voi folosi Opus ca să fiu în siguranță” este cel mai scump obicei de lăsat pe pilot automat.

5. Automatizați lucrurile pe care încă le faceți manual

După ce sursele de fricțiune dispar, următorul strat este munca pe care încă o faceți manual.

Sarcini programate

Este mai ușor decât să găsiți o cale să nu o faceți. Două funcționalități acoperă majoritatea: /loop pentru verificări recurente pe care altfel le-ați supraveghea și hooks pentru garanții pe care nu le puteți obține dintr-o instrucțiune în CLAUDE.md.

/loop rulează din nou un prompt sau o comandă cu slash la un interval recurent. Sintaxa are două forme:

• /loop 5m <prompt> rulează promptul la fiecare 5 minute

• /loop <prompt> singur cedează ritmul modelului, care decide când să ruleze din nou

Unitățile de interval sunt s, m, h și d, cu un minim de un minut. Aveți nevoie de Claude Code v2.1.72 sau mai recent.

De exemplu, puteți configura un watcher pentru teste: /loop 2m rulează suita de teste și raportează eșecurile. În loc să vă amintiți să rulați testele după fiecare schimbare (și să uitați jumătate din timp), Claude prinde un test stricat la următorul tic de 2 minute.

Același model funcționează pentru un poll al deploy-ului de staging (/loop 10m verifică dacă deploy-ul de staging e verde) sau pentru un tail de log în timpul unui incident instabil (/loop 1m tail la ultimele 50 de linii din app.log și semnalează erorile).

Loop-urile trăiesc 7 zile.

Sarcina pornește o ultimă dată în ziua a șaptea și se șterge. Sunt legate de sesiune, așa că --continue sau --resume le readuce dacă închideți și redeschideți. Pentru a opri un loop mai devreme, apăsați Esc. Dacă aveți nevoie de programare care supraviețuiește închiderii sesiunii (o verificare nocturnă, un rezumat săptămânal), folosiți Routines prin /schedule.

Hooks

Hooks sunt cealaltă jumătate. Rulează comenzi shell în puncte specifice ale fluxului de lucru al lui Claude, configurate în .claude/settings.json.

Motivul pentru a alege un hook în locul unei instrucțiuni în CLAUDE.md este unul: CLAUDE.md e consultativ, iar hooks sunt garantate să ruleze. Cazul clasic este regula „rulează întotdeauna linter-ul după editare” pe care Claude o sare uneori. Un hook închide acel gol.

Șase evenimente acoperă majoritatea cazurilor:

Un minimal hook PostToolUse care rulează linter-ul după fiecare editare de fișier:

{
  "hooks": {
	"PostToolUse": [
  	{
    	"matcher": "Edit|Write",
    	"hooks": [
      	{ "type": "command", "command": "/path/to/lint-check.sh" }
    	]
  	}
	]
  }
}

Un „gotcha” de ținut minte: doar codul de ieșire 2 chiar îl blochează pe Claude. Ieșirea 1 e tratată ca o eroare neblocantă, iar Claude continuă, deși 1 este de obicei codul de eșec în Unix. Dacă hook-ul trebuie să impună o regulă, returnați 2.

Nici nu trebuie să scrieți hooks de mână.

Promptați-l pe Claude cu „scrie un hook care rulează ruff după fiecare editare de fișier” și vă propune JSON-ul. /hooks listează fiecare configurație activă de hook, ca să nu fie nevoie să căutați prin fișierele de setări când ceva se declanșează neașteptat. Pentru catalogul complet de evenimente și schemele JSON pentru stdin/stdout, vedeți tutorialul meu despre hooks în Claude Code.

6. Țineți sub ochi cât costă toate acestea

Loop-uri, sesiuni lungi și Opus implicit ard tokeni. Trei comenzi fac cheltuielile suficient de vizibile pentru a fi gestionate, iar obiceiul dorit este să aruncați o privire la ele, nu să le configurați excesiv.

/usage afișează planul dumneavoastră, totalurile pe sesiune, defalcări de cost pe model și bare de progres pentru ferestrele de limitare de rată de 5 ore și săptămânale.

/context vizualizează fereastra de context curentă ca o grilă colorată, cu avertizări de capacitate și sugestii despre ce instrumente sau fișiere consumă spațiul. Folosiți-l când o sesiune se simte „grea” și decideți între /compact și /clear.

/statusline configurează o bară persistentă în partea de jos a terminalului. Poate arăta modelul, procentul de context, ferestrele de rate-limit și orice altceva ce poate fi citit din JSON-ul sesiunii. Este cea care schimbă cel mai mult comportamentul, pentru că pune numerele relevante de cost în câmpul dumneavoastră vizual periferic în timp ce lucrați.

Puteți rula /statusline și descrie în limbaj natural ce doriți afișat, iar Claude generează scriptul și actualizează setările. Cealaltă opțiune este să scrieți un script shell și să îl indicați din ~/.claude/settings.json:

{
  "statusLine": {
	"type": "command",
	"command": "~/.claude/statusline.sh"
  }
}

Pentru urmărire pe termen mai lung între sesiuni, npx ccusage este un instrument al comunității care agregă consumul de tokeni în timp. Este terț, nu construit de Anthropic, dar umple golul dintre /usage, care e la nivel de sesiune, și factura dumneavoastră lunară.

7. Încă trei lucruri care merită știute

Cele șase upgrade-uri de mai sus sunt cele la care apelez zilnic. Următoarele trei sunt funcționalități reale pe care le folosesc mai rar, dar pe care ar trebui să știți că există, ca să le puteți scoate în ziua în care aveți nevoie.

Folosiți push-to-talk cu /voice

/voice activează dictarea push-to-talk. Țineți apăsat Space, vorbiți, eliberați, iar textul transcris ajunge în câmpul de prompt. Aveți nevoie de v2.1.69 sau mai recent, și sunt suportate douăzeci de limbi.

Vocea tinde să bată tastarea când mergeți și gândiți cu voce tare sau dictați intenția la începutul unei sarcini, înainte ca formularea să fie definitivă. E mai slabă pentru editări la nivel de linie, unde „schimbă linia 47 în...” e mai ușor de tastat.

Aduceți sesiunile din cloud cu /teleport

/teleport (alias /tp) aduce o sesiune din cloud în terminalul local. Să zicem că ați început o sarcină lungă în aplicația web sau iOS, iar acum v-ați întors la laptop. Rulați claude --teleport pentru a deschide un selector și a aduce acea sesiune în terminal, cu branch-ul potrivit deja verificat (checked out).

Câteva cerințe trebuie să se alinieze:

• Stare git curată
• Repo-ul potrivit
• Același cont claude.ai care a rulat sesiunea din cloud
• Branch-ul a fost împins pe remote

Nu confundați --teleport cu --resume. Ultimul redeschide doar sesiunile locale din istoricul acestei mașini. Pentru un ghid mai aprofundat, tutorialul nostru despre control de la distanță în Claude Code acoperă restul.

Întrebări colaterale cu /btw

/btw este pentru întrebarea rapidă pe care vreți să o puneți fără a rupe fluxul.

Imaginați-vă că Claude este în mijlocul unei sarcini. Ați pornit deja o editare lungă sau un apel de instrument și, brusc, aveți nevoie să știți regex-ul pentru potrivirea IP-urilor sau care flag face X.

Puteți să tastați /btw <question>, iar răspunsul apare într-un overlay dismissibil. Sarcina în curs continuă, răspunsul nu intră în istoricul conversației, deci nu trebuie să porniți o sesiune nouă pentru o căutare punctuală și nici nu vă poluați sesiunea curentă.

Concluzie

Cea mai rapidă cale de a regresa pe tot ce e în acest articol este să încercați totul într-o singură zi. Alegeți două sau trei, construiți memoria musculară pentru acelea și adăugați restul mai târziu, când primul set devine automat.

Trei cu care să începeți, fiecare pentru o parte diferită a zilei, ca să nu se calce pe picioare:

• Un CLAUDE.md de proiect concis plus două-trei reguli wildcard de permisiuni în .claude/settings.json pentru comenzile bash pe care le reaprobați la fiecare sesiune. Acesta este obiceiul de „setup de dimineață” și îl simțiți doar când se opresc întreruperile.

• Decizia /compact versus /clear și selectorul de „rewind” pe Esc+Esc. Acesta este obiceiul de mijloc de sesiune, iar indiciul este momentul în care Claude cere din nou o cale de fișier pe care o știa acum o oră.

• Un /loop pentru o verificare recurentă care deja vă consumă timp. Acesta este obiceiul „în fundal” și, odată pornit, se amortizează singur.

Dacă diferența dintre Sonnet, Opus și Haiku încă este ceațoasă, cursul nostru Introducere în modelele Claude explică când se potrivește fiecare model. Asta face apelurile /effort și /model mult mai ușoare.