Terminalul și folderul de lucru: de unde să porniți Claude Code

La prima vedere, terminalul arată auster: o fereastră întunecată, un cursor care clipește și niciunul dintre butoanele obișnuite. În realitate, lucrurile sunt mult mai prozaice. E o cale directă de a-i spune calculatorului ce să facă: o comandă afișează fișierele, alta vă duce în folderul potrivit, a treia pornește un program.

Aproape toate blocajele de la începutul lucrului cu un agent nu țin de formularea cererii, ci de faptul că terminalul e deschis în alt folder decât trebuie. De aceea începem cu folderele și căile, iar la comanda claude ajungem abia după aceea. La final aplicăm totul pe proiectul codegym-project, unde fiecare sarcină trăiește ca proiect separat.

Terminalul - o cale directă de a controla proiectul

Terminalul este fereastra în care controlați calculatorul prin comenzi text. În loc să căutați butonul potrivit într-un meniu, numiți exact acțiunea: arată fișierele, deschide folderul, pornește programul.

Cu mouse-ul merge mai repede exact până în momentul în care trebuie să repetați aceeași acțiune a zecea oară. Iată ce vă oferă terminalul în schimb:

o comandă face o singură acțiune concretă - rezultatul apare în aceeași fereastră, nu e nimic de ghicit;
o succesiune de pași se repetă ușor - verificați folderul, vă uitați la fișiere, treceți în alt folder și porniți programul;
vedeți starea pe care interfața o ascunde - în primul rând folderul curent.

Nu trebuie să alegeți doar una dintre variante. În IDEA e comod să găsiți fișierele vizual și să le deschideți cu un clic, iar în terminal - să rulați o comandă precisă și să vedeți imediat răspunsul. În practică, cele două merg mereu mână în mână.

Și Claude Code se pornește printr-o comandă

Când tastați claude, agentul începe să lucreze din directorul curent al terminalului. De aceea e util să înțelegeți întâi unde se află terminalul și abia apoi să porniți agentul.

Cinci comenzi pentru lucrul de zi cu zi

Cinci acțiuni. La început chiar vă ajung. Pe Windows folosim PowerShell, iar pe macOS și Linux - terminalul standard. Comenzile scurte arată la fel în toate cele trei cazuri.

Comanda	Ce înseamnă	Ce face
`pwd`	`print working directory` - "afișează directorul de lucru"	Afișează calea completă către folderul în care se află acum terminalul.
`ls`	`list` - "listă"	Afișează fișierele și folderele din directorul curent.
`cd demo-project`	`change directory` - "schimbă directorul"	Trece în folderul `demo-project` aflat alături.
`cd ..`	`..` înseamnă directorul părinte	Mută terminalul cu un folder mai sus.
`claude`	Numele programului care se lansează	Pornește Claude Code din directorul curent.

În PowerShell, comenzile scurte sunt doar alias-uri comode: pwd apelează Get-Location, ls - Get-ChildItem, iar cd - Set-Location. Nu vă speriați de numele lungi și nici nu trebuie să le țineți minte acum. Dar din ele se vede bine ce face comanda.

Iar acum un scurt exemplu pentru macOS sau Linux. La început terminalul se află în folderul projects, apoi trece în demo-project:

Uitați-vă la ultima parte a căii: projects s-a schimbat în demo-project. Nicio magie. Comanda cd n-a deschis niciun fișier nou și n-a copiat nimic, doar a mutat poziția curentă a terminalului în alt folder.

Taste care economisesc timp

Există câteva obiceiuri care vă economisesc repede timp. Terminalul păstrează istoricul comenzilor introduse și vă ajută să completați numele lungi:

↑ - afișează comanda anterioară. Apăsați de mai multe ori ca să mergeți mai departe prin istoric;
↓ - vă întoarce la comenzile mai noi din istoric;
Tab - completează numele unei comenzi, al unui fișier sau al unui folder. De exemplu, tastați cd dem și apăsați Tab ca să obțineți cd demo-project;
← și → - mută cursorul în interiorul rândului, ca să corectați o literă fără să tastați din nou toată comanda;
Ctrl+C - de obicei oprește comanda în curs, dacă ați pornit ce nu trebuia sau procesul nu se mai termină;
Ctrl+L - curăță zona vizibilă a terminalului, dar nu șterge fișierele și nici istoricul comenzilor.

Cel mai des vă vor prinde bine săgeata în sus și Tab. Prima readuce o comandă deja introdusă, a doua reduce numărul de greșeli în căile lungi.

Folder, director și cale

Ați copiat o cale într-o comandă, ați trecut în alt folder - și aceeași comandă nu mai funcționează. Nu e vorba de o greșeală de tastare: căile sunt de două feluri, iar unul dintre ele depinde de locul în care se află acum terminalul. Le luăm pe rând pe amândouă.

Întâi despre denumiri, aici totul e mai simplu decât pare. Folder și director înseamnă același lucru. În interfață se spune mai des "folder", iar când e vorba de terminal - "director".

Calea este adresa unui director pe disc. Pe Windows, macOS și Linux separatorii arată diferit, dar logica e aceeași: fiecare segment al căii duce mai în adâncime. Întâi discul sau directorul rădăcină, apoi utilizatorul, folderul comun cu proiecte și, în sfârșit, proiectul concret.

Calea completă și calea absolută sunt același lucru, doar cu două denumiri. O astfel de cale pornește din vârful sistemului de fișiere: de la litera discului pe Windows sau de la simbolul / pe macOS și Linux. Ea duce în același loc indiferent de directorul în care e deschis acum terminalul.

Cu calea relativă e invers: ea descrie drumul pornind din directorul curent. Iese mai scurtă, pentru că partea de început a adresei nu mai trebuie repetată. Dar dacă treceți în alt folder, sensul căii se schimbă.

Să zicem că în proiect se află un astfel de fișier:

demo-project/
└── src/
    └── index.html

Terminalul e deschis în rădăcina lui demo-project. Iată două moduri de a ajunge la același index.html:

Sistemul	Calea completă, sau absolută	Calea relativă față de `demo-project`
Windows	`C:\Users\student\projects\demo-project\src\index.html`	`.\src\index.html`
macOS	`/Users/student/projects/demo-project/src/index.html`	`./src/index.html`
Linux	`/home/student/projects/demo-project/src/index.html`	`./src/index.html`

Punctul . înseamnă "directorul curent". De aceea .\src\index.html și ./src/index.html se citesc așa: "din folderul curent intră în src și ia index.html". Punctul e adesea omis: src\index.html și src/index.html înseamnă același lucru.

Dacă urcați din demo-project în folderul comun projects, vechea cale relativă nu mai funcționează. Din noul loc aveți nevoie de .\demo-project\src\index.html pe Windows sau de ./demo-project/src/index.html pe macOS și Linux. Calea completă, în schimb, rămâne neschimbată.

O cale cu spații se pune între ghilimele duble, altfel terminalul va considera că după spațiu începe deja un alt argument:

cd "C:\Users\student\My Projects\demo-project"

De ce contează directorul curent

Terminalul se află mereu într-un anumit director, chiar și înainte de prima comandă. Acesta se numește director curent sau director de lucru. De la el pornesc comenzile când caută fișiere și calculează căile relative.

Cu mouse-ul alegeți deja folderul

Trebuie să copiați un fișier din "Downloads" în "Secretele contabilității" din "Documents". Copiați fișierul, parcurgeți tot drumul până la folderul potrivit și abia acolo apăsați "Lipire". Fișierul se scrie pe disc la o singură adresă concretă. Nimeni nu lipește un fișier "undeva prin Documents" - de fiecare dată ajungeți exact la locul potrivit, doar că o faceți cu mouse-ul și nu vă gândiți la asta.

În terminal e aceeași treabă, doar că în locul ferestrei exploratorului de fișiere aveți un rând cu calea. Directorul îl alegeți tot dumneavoastră, iar din el începe să lucreze agentul.

Din punct de vedere tehnic, puteți deschide terminalul în rădăcina discului C:\. E o idee bună? Nu. Și nu pentru că Claude Code s-ar apuca să citească fiecare fișier de pe disc - n-o va face. Problema e că ați ales un punct de plecare prost:

agentul nu are o graniță clară a unui singur proiect - alături sunt fișiere de sistem, foldere ale utilizatorului și alte proiecte de-ale dumneavoastră;
căile relative încep în alt loc decât vă așteptați - src brusc nu mai e același src;
din cale nu vă puteți da seama cu ce proiect lucrați acum.

Mai e un mic detaliu de care vă puteți împiedica ușor: fișierul deschis în IDEA și directorul curent al terminalului sunt stări diferite. Vă puteți uita la un fișier dintr-un proiect, iar terminalul să fie în continuare în altul. Schimbarea tabului din editor nu mută terminalul deja deschis.

Punctul de plecare

Rădăcina proiectului este folderul de sus în care stau fișierele legate de un singur proiect: codul, setările, documentația și alte materiale necesare. Definiția formală nu trebuie tocită. E mai simplu să vă uitați la rol: acest folder adună un proiect întreg.

De exemplu, folderul comun projects poate conține mai multe proiecte independente:

projects/
├── demo-project/
│   ├── README.md
│   └── src/
└── calculator/
    ├── README.md
    └── src/

În acest arbore, projects e un container. Rădăcina primului proiect este demo-project, a celui de-al doilea - calculator. Tehnic, agentul poate fi pornit și din folderul comun, dar acolo e mai puțin context util: alături stau două proiecte fără legătură între ele.

În practică regula e scurtă: găsiți folderul de sus al proiectului pe care chiar vreți să-l modificați, deschideți terminalul acolo și porniți uneltele din el. Așa comenzile, fișierele și instrucțiunile proiectului ajung într-o singură zonă, ușor de înțeles.

Un folder prea larg estompează granițele sarcinii

Agentul studiază structura și fișierele din jurul sarcinii ca să înțeleagă contextul. Dacă îl porniți prea sus, alături vor fi și alte proiecte. La o cerere neclară, agentul poate decide că și ele țin de sarcină și poate modifica pe parcurs lucruri pe care nu i le-a cerut nimeni.

În focul lucrului e ușor să vedeți rezultatul așteptat și să scăpați din vedere modificările suplimentare din proiectul vecin. De aceea directorul de lucru corect nu e o formalitate, ci o graniță clară pentru agent.

Cum e organizat codegym-project

Și acum, cazul care ne interesează: CodeGym. Pluginul IDEA descarcă sarcinile într-un singur arbore mare, codegym-project. Din afară arată ca un singur proiect, dar înăuntru se ascunde o particularitate importantă: fiecare sarcină e un proiect separat.

Nu un fișier într-o grămadă comună, ci un proiect propriu: cu folderul lui, fișierele lui și propriile reguli pentru agent în .claude. Câte sarcini, atâtea proiecte. la propriu.

Simplificat, arborele arată așa:

codegym-project/
└── src/ro/codegym/claude/course/level01/
    ├── task05/
    │   ├── .claude/          # regulile agentului pentru task05
    │   └── arkanoid.html     # fișierul acestei sarcini
    └── task09/
        ├── .claude/          # reguli separate pentru task09
        ├── arkanoid.html
        ├── clicker.html
        └── tictactoe.html

Sunt aceleași birouri din analogia de mai sus, doar că acum au numere pe uși: task05 și task09. Fiecare are documentele și regulile lui, iar codegym-project e clădirea întreagă. Nu ajunge să chemați asistentul în hol, trebuie să numiți biroul în care se află lucrul curent.

O sarcină vecină nu completează contextul celei curente. Fișierele din task05 nu vă trebuie ca să rezolvați task09, iar regulile dintr-un folder nu le înlocuiesc pe cele din altul. De aceea, când lucrați cu CodeGym, rădăcina proiectului devine folderul sarcinii concrete, nu codegym-project comun.

O sarcină - o pornire

Rezolvați task09? Deschideți terminalul în task09 și porniți claude acolo. Rădăcina comună a cursului e prea largă pentru asta.

Pornim agentul în folderul sarcinii

Vestea bună: adresa lungă nu va trebui s-o tastați de mână. IDEA poate deschide terminalul direct în folderul ales.

Mai jos e tocmai metoda manuală. Da, Claude Code știe singur să treacă dintr-un director în altul și să ruleze comenzi în folderul potrivit. Dar merită totuși s-o înțelegeți o dată: nu depindeți de indicațiile agentului și vedeți imediat granițele sarcinii curente.

Găsiți taskXX de care aveți nevoie în arborele proiectului.
Faceți clic dreapta pe folderul sarcinii.
Alegeți Open In - Terminal.
Verificați directorul curent cu comanda pwd.
Verificați fișierele cu comanda ls.
Asigurați-vă că calea se termină cu taskXX de care aveți nevoie, apoi rulați claude.

IDEA afișează uneori folderele de package imbricate pe un singur rând, cu puncte, de exemplu ro.codegym.claude.course.level01. Nu retastați acest rând ca pe o cale de pe disc. E mai simplu să deschideți terminalul prin Open In - Terminal sau să copiați calea reală prin Copy Path/Reference.

Dacă terminalul e deja deschis în codegym-project, puteți trece acolo manual:

cd src/ro/codegym/claude/course/level01/task09
pwd
ls
claude

Sarcină nouă - director de lucru nou

Ați trecut de la task05 la task09? Sesiunea deschisă a agentului nu se mută singură după tabul din IDEA. Încheiați-o cu comanda /exit, deschideți terminalul în noua sarcină, verificați din nou calea și porniți claude.

O sesiune - o sarcină

Nu amestecați sarcini diferite în aceeași sesiune. În dialog rămân fișierele, deciziile și presupunerile de dinainte, așa că agentul poate duce contextul vechi în lucrul nou. Iese o salată din două sarcini, greu de descâlcit după aceea.

Vom vedea mai departe în curs de ce contează atât de mult contextul sesiunii și cum îl gestionați. Deocamdată țineți-vă de o regulă simplă: sarcină nouă - sesiune nouă.

Puteți ține deschise mai multe taburi de terminal, dar fiecare trebuie să aibă o sarcină clară. La început e mai simplu să închideți sesiunea veche înainte să treceți mai departe, ca să nu ghiciți pentru ce proiect lucrează acum agentul.

Dacă agentul e pornit prea sus

Calea se termină cu C:\, cu folderul dumneavoastră personal sau cu codegym-project în loc de taskXX? Opriți sesiunea, treceți în folderul sarcinii și porniți agentul din nou. Întâi corectăm adresa, apoi continuăm lucrul.

Cum funcționează asta împreună cu Claude Code

Să punem totul cap la cap. Terminalul nu-i dă lui Claude Code doar comanda de pornire, ci stabilește și punctul de plecare pentru structura proiectului, căile relative și instrucțiunile locale. Directorul curent arată de unde începe lucrul, iar rădăcina unui singur proiect îi dă agentului un set de fișiere legate între ele, fără zgomotul din jur.

De aici decurg două consecințe pe care e ușor să le uitați în focul lucrului. Tabul deschis în IDE nu schimbă directorul unei sesiuni deja pornite, așa că trecerea la altă sarcină înseamnă și director nou, și sesiune separată. Iar în codegym-project rădăcina unui proiect nu se află în vârful arborelui, ci la nivelul unui taskXX concret.

În practică, înainte de comanda claude ajung trei verificări rapide:

Uitați-vă la cale cu pwd.
Uitați-vă la fișiere cu ls.
Asigurați-vă că vedeți un singur proiect, cel de care aveți nevoie, și abia apoi porniți agentul.

Și cam atât. Terminalul nu complică aici lucrul, ci face vizibilă o setare invizibilă: știți exact unde vă aflați și ce proiect îi dați agentului.