Claude Code. Nu un chat, un sistem de lucru.

Lucrez cu Claude Code zi de zi, 7 din 7. Nu ca autocomplete, ci ca sistem: instrucțiuni scrise pe disc, skill-uri, subagenți, hooks și servere MCP. Pagina asta explică mecanismul, cu ce face bine și cu ce nu face.

$ claude

> /init

> citește src/lib și spune-mi ce face rate limiter-ul

$ claude mcp add --transport http context7 https://mcp.context7.com/mcp

$ claude mcp list

> rulează npm run typecheck și repară ce pică

Definiție

Ce este Claude Code

Claude Code este unealta de programare agentică de la Anthropic. Citește codul unui proiect, editează fișiere, rulează comenzi și se integrează cu uneltele de dezvoltare. Diferența față de un chat AI este simplă: la chat, tu ești transportul. Copiezi cod dintr-o fereastră în alta, lipești eroarea înapoi, ții tu firul. Aici agentul deschide singur fișierele, face modificarea, rulează testele și îți raportează ce a schimbat.

Rulează pe mai multe suprafețe care folosesc același motor: CLI în terminal, extensii pentru VS Code și JetBrains, aplicație desktop și varianta web la claude.ai/code. Aceleași fișiere de configurare, același CLAUDE.md, aceleași servere MCP funcționează pe toate. Alegi suprafața după cum lucrezi, nu după ce capabilități primești.

Un lucru trebuie înțeles înainte de orice altceva, fiindcă explică toată arhitectura din jur: fiecare sesiune pornește cu fereastra de context proaspătă. Firul conversației de ieri nu se reia. Ce traversează sesiunile sunt două mecanisme scrise pe disc: CLAUDE.md, pe care îl scrii tu, și memoria automată, pe care agentul și-o scrie singur, pornită implicit, într-un MEMORY.md din care se încarcă la fiecare sesiune primele 200 de linii sau primii 25KB, care vine primul. Amândouă intră în context ca instrucțiuni, nu ca reguli impuse. De aici vin cele șase straturi de extindere: CLAUDE.md, skill-uri, subagenți, hooks, servere MCP și plugin-uri.

Instrucțiunile se scriu în limbaj natural, inclusiv în română, cu diacritice. Eu scriu tot ce ține de reguli de proiect în română, iar codul rămâne în convențiile limbajului. Nu e o concesie, e o alegere: regulile pe care le citesc des trebuie să fie în limba în care gândesc.

Capabilități

Arborele de capabilități

Capabilitățile se așază pe trei niveluri, iar fiecare nivel îl presupune pe cel de dedesubt. Primul nivel e accesul brut la proiect: citește fișierele și le urmărește legăturile fără să i le lipești tu, scrie și modifică direct pe disc în mai multe fișiere din aceeași trecere, execută build, teste, git sau orice comandă din terminal și citește rezultatul.

Al doilea nivel e comportamentul de agent, adică ce face cu accesul ăla. Împarte o cerință în pași, ți-i arată înainte de execuție, apoi îi duce la capăt. Închide bucla de verificare: rulează testele, citește eroarea, repară, rulează din nou, până trece. Deleagă explorarea către un subagent cu context propriu și primește înapoi doar concluzia, nu tot ce a citit pe drum.

Al treilea nivel e sistemul din jur, cel pe care îl construiești tu. Prin MCP ajunge în baze de date, browser sau API-uri, nu doar în fișiere. Hooks rulează la momente fixe, indiferent ce decide modelul: formatare, blocaje, porți de calitate. CLAUDE.md, skill-uri și plugin-uri versionate dau întregii echipe același agent, cu aceleași reguli, nu configurația personală a fiecăruia.

Diferența dintre cineva care obține rezultate cu unealta asta și cineva care se plânge de ea stă aproape în întregime în nivelul al treilea. Nivelurile unu și doi vin din cutie.

01

Citire cod

Deschide fișierele proiectului și le urmărește legăturile, fără să i le lipești tu în chat.

Editare fișiere

Scrie și modifică direct pe disc, în mai multe fișiere din aceeași trecere.

Rulare comenzi

Execută build, teste, git sau orice comandă din terminal și citește rezultatul.

02

Plan executat

Împarte o cerință în pași, îi arată înainte de execuție, apoi îi duce la capăt.

Buclă verificare

Rulează testele, citește eroarea, repară și rulează din nou, până trece.

Căutare delegată

Trimite explorarea la un subagent cu context propriu și primește doar concluzia.

03

Unelte conectate

Prin MCP ajunge în baze de date, browser sau API-uri, nu doar în fișiere.

Reguli impuse

Hooks rulează la momente fixe, indiferent ce decide modelul: formatare, blocaje, porți.

Configurație comună

CLAUDE.md, skill-uri și plugin-uri versionate dau întregii echipe același agent.

Arhitectură

Straturile sistemului

CLAUDE.md este fișierul markdown cu instrucțiuni permanente, citit la începutul fiecărei sesiuni. Aici scrii o singură dată ce altfel ai repeta în fiecare conversație: comenzi de build, convenții de cod, structura proiectului. Se încarcă în ordine, de la politica organizației la ~/.claude/CLAUDE.md, apoi ./CLAUDE.md sau ./.claude/CLAUDE.md, apoi ./CLAUDE.local.md. Documentația recomandă sub 200 de linii per fișier, fiindcă fișierele lungi consumă context și scad aderența. Poate importa alte fișiere cu sintaxa @cale/către/fișier, recursiv, până la patru niveluri. Comanda /init generează un fișier de pornire, iar /memory listează fișierele de memorie.

Skill-urile sunt directoare cu un SKILL.md, frontmatter YAML plus instrucțiuni, pe care agentul le încarcă singur când sunt relevante sau le pornești tu cu /nume. Rolul lor e să mute procedurile repetitive din CLAUDE.md într-un loc care nu consumă context până e chemat: în context stă doar descrierea, tăiată la 1.536 de caractere, iar corpul se încarcă abia la invocare. Un skill poate aduce cu el șabloane, exemple și scripturi. Comenzile personalizate din .claude/commands/ au fost unificate cu skill-urile și funcționează în continuare la fel.

Subagenții sunt asistenți specializați care rulează în propria fereastră de context, cu prompt de sistem propriu și acces limitat la unelte. Îi definești ca fișiere markdown în .claude/agents/ pentru proiect sau ~/.claude/agents/ pentru toate proiectele. Valoarea lor practică e că țin căutările, log-urile și conținutul fișierelor în afara conversației principale și returnează doar rezumatul. Permit și control de cost, prin rutarea sarcinilor ieftine către un model mai ieftin. Vin și încorporați, iar cei pe care îi vezi cel mai des sunt Explore, pentru căutare în cod, și Plan, pentru cercetare în modul plan; alături de ei există general-purpose și câțiva agenți ajutători pe care Claude îi cheamă singur.

Hooks sunt comenzi shell, endpoint-uri HTTP, unelte MCP sau prompturi care se execută automat în puncte fixe: PreToolUse, PostToolUse, UserPromptSubmit, SessionStart, SessionEnd, Stop, PermissionRequest și altele. Sunt singurul strat care se execută indiferent de ce decide modelul. Acolo pui regulile care chiar trebuie să se aplice: formatare după fiecare editare, blocarea unei comenzi periculoase. Cod de ieșire 2 blochează acțiunea, 0 o lasă să continue, iar matcher-ul filtrează pe nume de unealtă, inclusiv cu regex. Documentația recomandă explicit hooks în locul CLAUDE.md pentru orice trebuie să ruleze la un moment precis.

Plugin-urile împachetează skill-uri, subagenți, hooks, servere MCP și LSP într-un singur director distribuibil și versionat, cu manifest la .claude-plugin/plugin.json. E forma în care dai o configurație echipei sau comunității, în loc să copiezi fișiere din .claude/ de la om la om. Numele skill-urilor sunt prefixate cu numele plugin-ului, deci mai multe plugin-uri coexistă fără conflicte, iar invocarea devine /nume-plugin:nume-skill.

CLAUDE.md

Fișier markdown cu instrucțiuni permanente, citit la începutul fiecărei sesiuni. Aici scrii o singură dată ce altfel ai repeta în fiecare conversație.

  • Se încarcă în ordine: politica organizației, ~/.claude/CLAUDE.md, ./CLAUDE.md sau ./.claude/CLAUDE.md, apoi ./CLAUDE.local.md
  • Documentația recomandă sub 200 de linii per fișier, fiindcă fișierele lungi consumă context și scad aderența
  • Poate importa alte fișiere cu sintaxa @cale/către/fișier, recursiv, până la patru niveluri de adâncime
  • Comanda /init generează un CLAUDE.md de pornire, iar /memory listează și deschide fișierele de memorie

Skill-uri

Un director cu un fișier SKILL.md, frontmatter YAML plus instrucțiuni, pe care agentul îl încarcă singur când e relevant sau îl pornești tu cu /nume.

  • Locații: ~/.claude/skills/<nume>/SKILL.md pentru personal, .claude/skills/<nume>/SKILL.md pentru proiect, plus cele din plugin-uri
  • În context stă doar descrierea, tăiată la 1.536 de caractere; corpul se încarcă abia la invocare
  • Câmpuri de frontmatter: description, when_to_use, allowed-tools, disallowed-tools, model, disable-model-invocation, context: fork
  • Comenzile personalizate din .claude/commands/ au fost unificate cu skill-urile și continuă să funcționeze la fel

Subagenți

Asistenți specializați care rulează în propria fereastră de context, cu prompt de sistem propriu, acces limitat la unelte și permisiuni independente.

  • Definiții ca fișiere markdown în .claude/agents/ pentru proiect sau ~/.claude/agents/ pentru toate proiectele
  • Frontmatter: name, description, tools, model; fără câmpul tools, subagentul moștenește uneltele sesiunii
  • Cei mai vizibili subagenți încorporați: Explore, pentru căutare în cod, și Plan, pentru cercetare în modul plan; mai există general-purpose și câțiva agenți ajutători
  • Subagenții veniți din plugin-uri ignoră câmpurile hooks, mcpServers și permissionMode, din motive de securitate

Hooks

Comenzi shell, endpoint-uri HTTP, unelte MCP sau prompturi care se execută automat în puncte fixe din ciclul de viață al sesiunii.

  • Evenimente: PreToolUse, PostToolUse, UserPromptSubmit, SessionStart, SessionEnd, Stop, PermissionRequest și altele
  • Se configurează în ~/.claude/settings.json, .claude/settings.json, hooks/hooks.json dintr-un plugin sau în frontmatter
  • Cod de ieșire 2 blochează acțiunea, 0 o lasă să continue; matcher-ul filtrează pe nume de unealtă, inclusiv regex
  • Tipuri de handler: command, http, mcp_tool, prompt și agent

Servere MCP

Model Context Protocol este standardul deschis prin care Claude Code se conectează la unelte, baze de date și API-uri externe.

  • Transporturi acceptate: stdio, HTTP, recomandat pentru servere la distanță, SSE, depreciat, și WebSocket
  • Trei scopuri: local și user în ~/.claude.json, project în .mcp.json din rădăcina proiectului, care se poate comite
  • Adăugare cu claude mcp add --transport http nume url; claude mcp list arată starea fiecărei conexiuni
  • Resursele se citează cu @server:protocol://cale, iar prompturile apar ca /mcp__server__prompt

Plugin-uri

Un pachet care grupează skill-uri, subagenți, hooks, servere MCP și LSP într-un singur director, distribuibil și versionat.

  • Manifest la .claude-plugin/plugin.json cu name, description și version; celelalte directoare stau în rădăcina plugin-ului
  • Poate conține skills/, agents/, hooks/hooks.json, .mcp.json, .lsp.json, monitors/, bin/ și settings.json
  • Skill-urile de plugin se invocă prefixate: /nume-plugin:nume-skill
  • Distribuția se face prin marketplace-uri; Anthropic menține claude-plugins-official și claude-community
Anatomia unei sesiuni Claude Code: ce se încarcă la pornire, din politica organizației până la fișierele locale de proiect
Anatomia unei sesiuni: ce citește agentul la pornire
Conectare

MCP, conexiunea la lumea reală

Model Context Protocol este standardul deschis prin care Claude Code se conectează la unelte, baze de date și API-uri externe. Rezolvă o problemă foarte concretă: fără el, tot ce e în afara fișierelor ajunge în conversație prin copy-paste. Exporți un rezultat SQL, îl lipești, agentul lucrează pe o poză veche a datelor. Cu un server MCP, interoghează direct schema și datele, deschide un browser și verifică pagina reală, citește issue-uri și deschide pull request-uri, aduce documentația actuală a unei librării în loc să se bazeze pe memorie, păstrează decizii între sesiuni într-un depozit structurat.

Transporturile acceptate sunt stdio, HTTP, care e recomandat pentru servere la distanță, SSE, depreciat, și WebSocket. Scopurile sunt trei: local și user, în ~/.claude.json, și project, în .mcp.json din rădăcina proiectului. Ultimul se poate comite, iar asta e partea care contează în echipă: un server de proiect versionat dă tuturor același set de unelte, nu configurația de pe laptopul unuia.

Adăugarea se face cu claude mcp add --transport http nume url, iar claude mcp list arată starea fiecărei conexiuni. Resursele se citează cu @server:protocol://cale, iar prompturile expuse de server apar ca /mcp__server__prompt.

Eu am 12 servere configurate manual, în cele trei locuri de configurare. Unul dintre ele e nefuncțional și e marcat ca atare în documentația mea de proiect, ca să nu-l mai chem. Nu am scris niciun server MCP, sunt pachete terțe. Le-am configurat, ceea ce e o treabă diferită și merită numită corect. Aceeași conectare stă la baza lucrului meu pe agenți AI pentru automatizări de business.

AGENTMCP

  • Baze de date

    Interoghează schema și datele direct, fără export manual în conversație.

  • GitHub

    Citește issue-uri, deschide pull request-uri și urmărește starea unui branch.

  • Browser

    Navighează, completează formulare și verifică o pagină reală, nu doar codul ei.

  • Fișiere externe

    Acces controlat la directoare din afara proiectului curent.

  • Documentație

    Aduce documentația actuală a unei librării, în loc să se bazeze pe memorie.

  • Memorie

    Păstrează decizii și context între sesiuni, într-un depozit structurat.

Harta serverelor MCP: agentul în centru, conectat la baze de date, browser, GitHub, fișiere externe, documentație și memorie
Harta conexiunilor MCP dintr-un proiect real
Flux

Cum arată un proiect de la cap la coadă

Fluxul are cinci porți. Nu sunt o metodologie de manual, sunt ordinea în care lucrez efectiv, fiindcă orice altă ordine mă costă timp pe care l-am măsurat.

  1. Context

    Citește codul existent și fișierele de reguli înainte să propună ceva.

  2. Plan

    Scrie pașii și fișierele atinse, ca să poți corecta direcția înainte de cod.

  3. Implementare

    Editează fișierele vizate, în modificări mici și verificabile una câte una.

  4. Verificare

    Typecheck, lint și teste, întâi pe ce a atins, apoi suita completă.

  5. Livrare

    Diff citit de om, commit cu mesaj clar și pull request sau deploy.

Prima poartă e contextul. Agentul citește codul existent și fișierele de reguli înainte să propună ceva. Un agent care propune fără să fi citit e un generator de text plauzibil. Aici se plătește CLAUDE.md-ul scris bine.

A doua e planul. Scrie pașii și fișierele pe care le atinge, ca să pot corecta direcția înainte de cod. Corecția asta costă un minut. Aceeași corecție după implementare costă o oră. Un brief neclar e bani aruncați, iar la agenți se vede imediat.

A treia e implementarea, în modificări mici și verificabile una câte una. A patra e verificarea: typecheck, lint și teste, întâi pe ce a atins, apoi suita completă, o singură dată, la final. Am ajuns la regula asta după ce mi-am măsurat propriile sesiuni și am văzut cât timp pierdeam rulând suita întreagă la fiecare editare.

A cincea e livrarea: diff citit de om, commit cu mesaj clar, pull request sau deploy. Diff-ul citit de om nu e opțional. E singurul loc din flux unde răspunderea se întoarce complet la mine, și trebuie să rămână acolo.

Lanțul porților de regresie: scrie, verificare de tipuri, lint, teste, build, apoi livrare. Când testele pică, o buclă de reparare trimite înapoi la scriere.
Porțile de regresie din poarta de verificare, cu bucla de reparare
Practică

Ce am construit așa

Cel mai mare proiect dus cu fluxul ăsta e o aplicație web construită cu ajutorul agenților AI pentru o firmă de montaj: peste 70.000 de linii de cod în src, 506 fișiere, 74 de migrații de bază de date cu 47 de tabele, 79 de fișiere de test. Toate cele 28 de commituri sunt ale mele. Înainte de prima linie de cod au existat 26.943 de linii de documentație de proiect: plan, specificație, model de date, design, stack, anexe. Nu scriu documentația ca formalitate. O scriu fiindcă un agent care citește specificația scrisă propune altceva decât unul care ghicește.

Din specificația aia au ieșit 116 reguli de construcție numerotate, C1 la C116, iar o parte dintre ele sunt marcate ca porți și verificate automat. Sunt 24 de comenzi de verificare care pică livrarea dacă o regulă e încălcată, din cele 60 de scripturi npm ale proiectului. Regula scrisă în CLAUDE.md e context, nu constrângere. Regula transformată în poartă e constrângere. Diferența asta e tot ce contează când lucrezi cu un agent care uneori scrie cod plauzibil și greșit.

Site-ul pe care îl citești are 191 de commituri, toate ale mele, 35 de pagini, 29 de rute API și 18 tabele în spate. Tot cu fluxul ăsta am scris patru agenți Python autonomi, pentru licitații publice, prospectare și promovare. Doi dintre ei au istoric git, peste 23.000 de linii de Python. Ceilalți doi rulează local, fără versionare, deci nu îi trec la cifre verificabile. Poți vedea și proiecte livrate cu acest flux de lucru. Țin și un fișier de decizii acceptate, ca să nu reapară aceleași constatări la fiecare audit, inclusiv compromisuri asumate explicit, de tipul rate limit fail-open ca să nu pierd lead-uri dacă pică baza de date.

Pe partea de configurare a uneltei: am 137 de skill-uri instalate în ~/.claude/skills, dar hai să fim exacți, fiindcă cifra aia circulă umflată. 57 sunt symlink-uri către biblioteci ale altora, 25 vin dintr-o clonă, 38 declară explicit alt autor în fișier. Scrise de mine sunt 3, pentru fluxurile mele repetitive: carusele Instagram, execuția planului SEO pe loturi și generarea de idei de video doar din date proprii. Am scris în schimb hook-uri proprii, un strat de instrucțiuni pe patru niveluri și o unealtă care citește transcripturile de sesiune și împerechează fiecare apel de unealtă cu rezultatul lui, ca să măsoare timpul real. 847 de minute pe 30 de sesiuni. De acolo au ieșit regulile de viteză pe care le respect acum.

116

reguli de construcție numerotate, scrise înainte de cod

24

porți de regresie automate care pică livrarea

26.943

linii de documentație de proiect scrise înaintea implementării

74

migrații SQL versionate, 47 de tabele

79

fișiere de test în aplicația principală

191

commituri pe dmaster.ro, toate ale mele

Lucrez cu Claude Code zi de zi, 7 din 7. Am 3.925 de transcripturi de sesiune pe disc, în 18 proiecte. Nu e o unealtă pe care am testat-o. E felul în care construiesc.

Prefer cifra verificabilă în locul celei impresionante. De asta fiecare număr de mai sus vine dintr-o comandă rulată pe disc, nu dintr-o estimare.

Limite

Ce face bine și ce nu face

Ce face

  • Lucrează în proiecte mari, unde trebuie întâi să înțeleagă cod scris de altcineva.
  • Închide singur bucla: rulează testele, citește eroarea, repară, rulează din nou.
  • Face modificări coordonate în zeci de fișiere, nu doar fragmente izolate.
  • Se conectează prin MCP la baze de date, browser și API-uri, deci verifică în sistemul real.
  • Se personalizează pe proiect prin fișiere versionate, aceleași pentru toată echipa.
  • Duce sarcini lungi și plictisitoare: migrări, refactorizări repetitive, curățare de cod mort.

Ce nu face

  • Nu reia firul conversației de ieri. Ce vrei garantat la pornire scrii tu în CLAUDE.md, restul rămâne pe seama memoriei automate.
  • Nu garantează corectitudinea. Scrie uneori cod plauzibil și greșit, care compilează.
  • Nu poate verifica ce proiectul nu verifică. Fără teste, rămâne doar cu părerea lui.
  • Instrucțiunile din CLAUDE.md sunt context, nu constrângere. Ce chiar trebuie impus se pune în hooks.
  • Nu decide ce merită construit. Prioritățile, compromisurile de produs și răspunderea rămân la tine.
  • Nu vede ce nu i-ai dat acces: sisteme fără MCP, medii de producție, discuții din afara terminalului.

Instrucțiunile din CLAUDE.md sunt context, nu constrângere. Ce chiar trebuie impus se pune în hooks, care rulează indiferent de ce decide modelul. Cine confundă cele două straturi ajunge să scrie reguli în majuscule și să se mire că nu se aplică.

Nu decide ce merită construit. Prioritățile, compromisurile de produs și răspunderea rămân la tine. Nu vede ce nu i-ai dat acces: sisteme fără MCP, medii de producție, discuții din afara terminalului.

Regula practică pe care o aplic e simplă. Lucrez doar în proiecte sub control de versiune, pe ramură separată, și țin operațiunile ireversibile, ștergeri de date de producție sau publicare în producție, ca decizie umană. Nu e vorba că generez cod mai repede. E vorba că pot duce singur un proiect întreg. Dacă vrei să vezi cum se traduce asta pe un caz concret, discutăm despre proiectul tău.

Întrebări

Întrebări frecvente

Primele zile sunt mai lente decât fără el, fiindcă scrii fișierul de instrucțiuni al proiectului și îți așezi verificările. Câștigul apare după ce agentul are context scris și porți automate care prind greșelile. Dacă renunți în ziua a doua, ai plătit costul de învățare fără să iei beneficiul.

Da. Poți scrie instrucțiunile în română, cu diacritice, iar răspunsurile și explicațiile vin tot în română dacă ceri asta. Codul generat rămâne în convențiile limbajului de programare, adică numele de variabile și comentariile pot fi în engleză sau în română, după cum stabilești tu în fișierul de configurare al proiectului.

Când sarcina produce mult text pe care nu vrei să îl ții în conversația principală: căutări prin cod, citit log-uri, explorat fișiere mari. Subagentul rulează în fereastra lui de context și returnează doar concluzia, nu tot ce a citit pe drum. Așa firul principal rămâne curat, iar sarcinile ieftine pot merge pe un model mai ieftin.

MCP, adică Model Context Protocol, este un standard deschis lansat de Anthropic prin care un agent AI se conectează la surse de date și unelte externe: baze de date, sisteme de fișiere, browser, API-uri de business. Practic, MCP înlocuiește zeci de integrări scrise separat cu un singur mod standard de conectare. Pentru Claude Code, un server MCP înseamnă că agentul poate interoga direct baza de date a proiectului sau poate deschide un browser, nu doar poate scrie cod despre ele.

CLAUDE.md este un fișier text pus în rădăcina proiectului, pe care Claude Code îl citește automat la fiecare pornire. Conține regulile proiectului: structura folderelor, comenzile de rulare și de testare, convențiile de cod, lucrurile interzise. Este cea mai ieftină investiție de timp dintr-un proiect cu agent AI, pentru că elimină nevoia de a repeta același context la fiecare sesiune.

Claude Code cere permisiune înainte de acțiuni care schimbă starea sistemului, iar tu decizi ce aprobi o dată și ce aprobi permanent. Regula practică este să lucrezi doar în proiecte aflate sub control de versiune, pe o ramură separată, astfel încât orice modificare să fie reversibilă cu o singură comandă. Operațiunile ireversibile, cum sunt ștergerile de date de producție sau publicarea în producție, ar trebui păstrate mereu ca decizie umană.

Da, și acolo se vede cel mai bine diferența față de un chat. Agentul citește codul existent și îi urmărește legăturile singur, fără să îi lipești tu fișiere. Pe un proiect vechi, primul lucru util e să pui pe hârtie ce face proiectul și cum se rulează, fiindcă un agent care are context scris propune altceva decât unul care ghicește.

Da, rulează nativ pe Windows, pe macOS și pe Linux. Pe Windows se instalează prin npm sau prin instalatorul nativ și funcționează atât în PowerShell, cât și în Git Bash sau în WSL. Diferența practică pe Windows ține de sintaxa comenzilor de shell, motiv pentru care merită specificat în CLAUDE.md ce shell folosești.

Următorul pas

Vrei fluxul ăsta pe proiectul tău

Construiesc aplicații web construite cu ajutorul agenților AI și scriu agenți AI pentru automatizări de business. Același flux: specificația întâi, porți automate care opresc livrarea, diff citit de om la final. Poți vedea cine sunt și cum lucrez, proiecte livrate cu acest flux de lucru, sau putem discuta direct despre proiectul tău.