Cum adaugi flag-uri la comenzile slash din Claude Code: 4 pattern-uri care chiar funcționează

Cum adaugi flag-uri la comenzile Slash din Claude Code: 4 pattern-uri care chiar funcționează

Claude Code nu parsează de fapt --flags așa cum te-ai aștepta pentru comenzile slash personalizate, dar patru pattern-uri îți oferă aceeași experiență UX, iar trei dintre ele sunt mai curate decât parsarea CLI clasică. Iată cum adaugi flag-uri la comenzile slash din Claude Code corect, cu fișiere .md funcționale pe care le poți copia chiar acum.

Răspuns rapid:

• Claude Code nu parsează flag-uri CLI (--json, --verbose) pentru comenzile personalizate, utilizatorul nu are un parser de flag-uri.
• Pentru UX în stil CLI, scrie flag-urile în $ARGUMENTS și lasă LLM-ul să le interpreteze ca limbaj natural.
• Pentru argumente tipizate, folosește argumente poziționale $1/$2 sau argumente numite declarate în câmpul arguments: din frontmatter.
• Documentează flag-urile așteptate în argument-hint: pentru ca autocompletarea la / să le afișeze utilizatorului.

Cum funcționează de fapt argumentele comenzilor slash din Claude Code?

Utilizarea din Claude Code înlocuiește trei tipuri de tokenuri înainte de a trimite comanda către LLM: $ARGUMENTS (întregul șir de caractere de după numele comenzii), poziționale $0/$1/$2 (segmente între ghilimele în stil shell) și numite $variableName declarate în frontmatter. Nu există un parser de flaguri CLI încorporat, --dry-run ajunge în $ARGUMENTS ca text literal.

Iată partea care îi încurcă pe toți. Când tastezi /deploy --staging --dry-run, Claude Code nu rulează argparse pe --staging --dry-run. Utilizarea lipește întregul șir acolo unde fișierul .md face referire la $ARGUMENTS, apoi trimite promptul randat către model. LLM-ul vede --staging --dry-run ca text simplu și decide ce să facă.

Nu este un bug, ci designul. Utilizarea este un strat de substituție, nu un parser. Comenzile încorporate precum /clear și /help (vezi referința oficială CLI) au flaguri, dar comenzile personalizate pe care le creezi funcționează după reguli diferite.

Utilizarea din Claude Code înlocuiește tokenurile, apoi transmite promptul randat către LLM. Nu există un parser de flaguri.

În propria noastră activitate cu Claude Code, cea mai frecventă confuzie este exact aceasta: dezvoltatorii petrec o oră încercând să-și dea seama de ce --verbose „nu este detectat”, înainte să realizeze că LLM-ul este parserul. Începând cu Claude Code v2.1.126 (mai 2026), acest comportament este documentat în documentația oficială a comenzilor slash și nu se va schimba prea curând. Comenzile slash sunt un primitiv înrudit cu hook-urile Claude Code — ambele extind utilizarea, dar comenzile se declanșează la inputul utilizatorului, în timp ce hook-urile se declanșează la evenimentele instrumentelor.

Iată cea mai mică comandă personalizată posibilă care demonstrează modelul de substituție:

---
description: Echo whatever the user types after the command
argument-hint: [anything]
---

The user passed these arguments: $ARGUMENTS

Repeat them back verbatim, then describe what the user probably meant.

Salveaz-o ca .claude/commands/echo-args.md, tastează /echo-args hello world --foo, iar LLM-ul va vedea șirul literal hello world --foo substituit în prompt. Acesta este întregul model mental. Pentru o explicație mai aprofundată a modului în care fișierele de comenzi se leagă de sistemul de skills mai larg, vezi Ghidul nostru introductiv despre Skills.

Construiește primul tău Slash Command parametric în 5 minute

Creează .claude/commands/greet.md cu trei linii de frontmatter și o linie de prompt care referențiază $ARGUMENTS. Repornește Claude Code, tastează /greet World și privește cum World se substituie în prompt înainte ca LLM-ul să îl vadă. Asta e toată ceremonia: cinci pași, fără instrumente de build.

Iată rețeta cap-coadă:

1. Creează directorul. Din rădăcina proiectului tău, rulează mkdir -p .claude/commands. Folderul .claude/ se află lângă codul tău; comenzile din interiorul lui sunt descoperite automat când Claude Code pornește o sesiune.
2. Scrie fișierul de comandă. Salvează fragmentul de mai jos ca .claude/commands/greet.md.
3. Reîncarcă sesiunea. Închide și repornește Claude Code (sau rulează /reload dacă versiunea ta îl suportă). Comenzile sunt citite o singură dată la pornirea sesiunii.
4. Invoc-o. Tastează /greet World în chat.
5. Verifică substituția. Deschide transcriptul și confirmă că LLM-ul a văzut World interpolat în corpul promptului, nu tokenul literal $ARGUMENTS.

Iată fișierul complet:

---
description: Greet someone enthusiastically
argument-hint: <name>
---

You are a friendly assistant. Greet the person named "$ARGUMENTS" with one short, warm sentence. Then ask them what they're working on today.

Și interacțiunea din terminal:

> /greet World
Hey World, great to see you! What are you working on today?

Gata. Acum ai o comandă slash parametrică. Câmpul argument-hint este cel care face ca meniul de autocompletare / să afișeze <name> lângă comanda ta — o mică atingere UX, un câștig mare.

Dacă $ARGUMENTS nu se substituie, de 9 ori din 10 este pentru că ai tastat $args sau $ARGS — tokenul este literal, cu majuscule.

Tokenul este sensibil la majuscule și exact. $ARGUMENTS funcționează. $arguments, $args, $ARGS, ${ARGUMENTS} eșuează toate silențios — sunt trimise LLM-ului ca text literal, iar modelul vede doar gunoi. Verifică de trei ori ortografia înainte să presupui un bug mai adânc.

Ce câmpuri din frontmatter controlează tratarea argumentelor?

Cinci câmpuri din frontmatter determină modul în care o comandă slash tratează argumentele: argument-hint (ce afișează autocompletarea), allowed-tools (ce poate apela comanda), arguments (declararea argumentelor numite), model (ce variantă de Claude o rulează) și disable-model-invocation (blochează comanda doar pentru invocare de către utilizator). Împreună, acestea acoperă practic orice model parametric de care vei avea nevoie.

Iată referința completă pentru frontmatter pentru comenzile personalizate Claude Code v2.1.x:

Două capcane care merită lipite pe monitor. În primul rând, allowed-tools este separat prin spații, nu prin virgule. Dacă scrii Bash(git:*), Read, Edit, nu se va adăuga nimic în lista albă, fără niciun avertisment, parserul tratează întregul șir ca pe o singură intrare malformată. Folosește Bash(git:*) Read Edit. Am învățat asta pe pielea noastră; pentru mai multe astfel de tipare, vezi cele mai bune practici CLAUDE.md despre convențiile fișierelor de configurare.

În al doilea rând, câmpul model: suprascrie orice model a selectat utilizatorul pentru sesiunea curentă. Util când o comandă este ieftină din punct de vedere computațional și vrei să o forțezi pe o variantă mai mică, vezi ghidul nostru despre selectarea modelului pentru a alege între Opus 4.7 și Sonnet pentru diferite tipuri de comenzi.

Câmpul disable-model-invocation: true este plasa ta de siguranță pentru comenzile distructive. Setează-l pentru /deploy-prod sau /drop-database, iar alți agenți nu vor putea apela aceste comenzi programatic, doar un om care tastează în chat le poate declanșa.

Care sunt cele 4 tipare de argumente pe care le vei folosi de fapt?

Patru tipare acoperă aproximativ 95% din comenzile slash reale din Claude Code: (1) flag boolean precum /deploy --dry-run, analizat de LLM din $ARGUMENTS, (2) flag cu valoare precum /test --filter auth, extras din $ARGUMENTS, (3) argument pozițional obligatoriu + flag opțional precum /fix-issue 123 --priority high, care combină $1 și $ARGUMENTS, și (4) argument pozițional strict tipat precum /migrate-component SearchBar React Vue, folosind $0/$1/$2.

Alege-l pe cel care se potrivește formei comenzii tale. Iată un fișier .md funcțional pentru fiecare.

Pattern 1: Flag boolean (--dry-run)

Când vrei UX de flag CLI și flag-ul este doar on/off, lasă LLM-ul să îl detecteze în $ARGUMENTS. Fără logică de parsare, fără jonglerie cu argumente poziționale — doar descrii regula în prompt.

---
description: Deploy to staging or production
argument-hint: [--dry-run]
allowed-tools: Bash(git:*) Bash(npm:*) Read
---

Deploy the current branch to staging.

Arguments passed: $ARGUMENTS

If "$ARGUMENTS" contains "--dry-run", DO NOT actually deploy. Instead, print the deployment plan: which files would change, which env vars would be set, and which commands would run. Stop after printing the plan.

Otherwise, proceed with the real deployment using `git push staging main` and `npm run deploy:staging`.

Tastezi /deploy --dry-run și LLM-ul vede flag-ul, afișează planul și se oprește. Tastezi /deploy și livrează. Utilizatorul nu a făcut nicio parsare, LLM-ul a făcut toată treaba — exact lucrul la care se pricepe cel mai bine.

Pattern 2: Value Flag (--filter <pattern>)

Aceeași idee, dar acum flag-ul poartă o valoare. LLM-ul citește --filter auth din $ARGUMENTS și folosește subșirul de după el.

---
description: Run the test suite, optionally filtered
argument-hint: [--filter <pattern>]
allowed-tools: Bash(npm:*) Read
---

Run the project's test suite.

Arguments: $ARGUMENTS

If "$ARGUMENTS" contains "--filter <pattern>", run only tests matching <pattern>. Use `npm test -- --grep <pattern>` for the actual command.

If no `--filter` is present, run the full suite with `npm test`.

Report pass/fail counts at the end.

/test --filter auth rulează doar testele de auth. /test rulează totul. LLM-ul extrage pattern-ul de după --filter în mod fiabil, deoarece Claude este cu adevărat bun la acest tip de extragere din text structurat, mult mai fiabil decât se așteaptă lumea.

Modelul 3: Pozițional obligatoriu + flag opțional

Acesta este hibridul pe care îl folosim cel mai mult în propria noastră bibliotecă de comenzi. $1 poartă argumentul obligatoriu, $ARGUMENTS poartă totul (astfel încât LLM-ul poate detecta în continuare flag-urile opționale). Este cea mai curată combinație atunci când un argument este nenegociabil, iar restul este context în formă liberă.

---
description: Fix a GitHub issue
argument-hint: <issue-number> [--priority high|medium|low] [context...]
allowed-tools: Bash(gh:*) Bash(git:*) Read Edit
---

Fix GitHub issue #$1.

Full arguments: $ARGUMENTS

Steps:
1. Run `gh issue view $1` to load the issue body.
2. Read the codebase to locate the relevant file(s).
3. If "$ARGUMENTS" contains "--priority high", create a hotfix branch off main. Otherwise branch off develop.
4. Apply the fix, run tests, and open a PR linked to the issue.

Anything else in $ARGUMENTS after the issue number is freeform context — fold it into your understanding of the bug.

Invocă-l ca /fix-issue 1234 --priority high the login form blanks the email field after a failed attempt. $1 se rezolvă la 1234. $ARGUMENTS se rezolvă la întregul șir de la final, pe care LLM-ul îl analizează cu plăcere atât pentru flag-ul de prioritate, cât și pentru descrierea în formă liberă.

Folosim exact această combinație $1 + $ARGUMENTS în comanda noastră /fix-issue, $1 pentru numărul issue-ului, iar restul pentru contextul în formă liberă pe care LLM-ul îl analizează. A fost modelul cu cel mai mare ROI de-a lungul unui an de utilizare zilnică a Claude Code.

Pattern 4: Pozițional strict (tipizat)

Când fiecare argument este obligatoriu și ordinea contează, renunță complet la $ARGUMENTS. Folosește $0/$1/$2 (sau argumente numite prin câmpul arguments: din frontmatter) pentru sloturi tipizate neechivoce.

---
description: Migrate a component between frameworks
argument-hint: <component> <from-framework> <to-framework>
arguments: [component, fromFramework, toFramework]
allowed-tools: Read Edit Write
---

Migrate the component named "$component" from $fromFramework to $toFramework.

1. Read the existing component file (search for `$component.{jsx,tsx,vue,svelte}`).
2. Translate the component idioms from $fromFramework to $toFramework: lifecycle methods, state handling, prop syntax, event binding.
3. Write the new file in the matching extension for $toFramework.
4. Print a diff summary at the end.

If $fromFramework or $toFramework is unsupported, abort and tell the user which frameworks ARE supported (React, Vue, Svelte, Solid).

Se invocă sub forma /migrate-component SearchBar React Vue. Declararea argumentelor numite face ca autocompletarea și corpul promptului să fie auto-documentate; oricine citește migrate-component.md poate înțelege dintr-o privire care slot este care. Acest pattern excelează pentru comenzile cu trei sau mai multe argumente obligatorii. Poți vedea acest stil și în biblioteci din comunitate, precum wshobson/commands pe GitHub.

Flagurile booleene și cele cu valori funcționează pentru că LLM-ul este un parser flexibil. Poziționalul strict funcționează pentru că nu este necesară nicio inteligență a LLM-ului. Combinarea celor două este secretul.

Când ar trebui să folosești $ARGUMENTS vs. poziționale vs. numite?

Folosește $ARGUMENTS când argumentele sunt de tip flag CLI și vrei o parsare flexibilă de către LLM. Folosește poziționale $1/$2 când argumentele sunt tipizate, ordonate și vrei zero ambiguitate din partea LLM-ului. Folosește arguments: numite când sunt 3+ argumente și claritatea în autocompletare contează mai mult decât concizia. Iată matricea de decizie:

Instinctul pe care îl au majoritatea dezvoltatorilor este să apeleze mai întâi la $ARGUMENTS, pentru că se simte cel mai aproape de lumea bash pe care o cunosc. E în regulă pentru prototipuri, dar poziționalele tipizate sunt cu adevărat mai bune când contractul este stabil. LLM-ul nu trebuie să parseze $1, e deja un șir curat.

O regulă aproximativă: dacă poți descrie semnătura comenzii într-o singură propoziție în română fără să folosești cuvintele „sau" și „opțional", mergi pe poziționale. Dacă ai nevoie de aceste cuvinte, mergi pe $ARGUMENTS.

Sunt comenzile Slash același lucru cu Skills acum?

Anthropic a integrat comenzile personalizate în sistemul mai larg de skills în primăvara anului 2026, dar fișierele .claude/commands/*.md funcționează în continuare și folosesc același frontmatter. Un skill este un director (.claude/skills/foo/SKILL.md plus fișiere auxiliare) cu control suplimentar de invocare, precum disable-model-invocation. O comandă este un singur fișier .md. Aceleași reguli de substituție, ambalaj diferit.

Iată diferența practică:

Deci nu, .claude/commands/ nu este depreciat. Anthropic a păstrat în mod explicit funcțional formatul de fișier atunci când a fuzionat sistemele, prea multe proiecte au biblioteci de comenzi fixate în controlul versiunilor. Dacă vrei fișiere auxiliare (cum ar fi o referință CONTRIBUTING.md pe care skill-ul tău o încarcă sau un template.json pe care îl copiază), apelează la skills. Altfel, rămâi la comenzi.

Fuziunea face parte dintr-o mișcare mai amplă către standardul deschis agentskills.io și este una dintre mai multe modificări v2.1.x care merită cunoscute, vezi rezumatul nostru despre funcționalitățile Claude Code v2.1 pentru peisajul complet al funcționalităților și tutorialul nostru despre skills pentru o prezentare mai detaliată a skills.

De ce nu se substituie $ARGUMENTS? Erori frecvente rezolvate

Cinci motive frecvente pentru care $ARGUMENTS nu se substituie: (1) token scris cu minuscule sau prescurtat ($args, $ARGS, $arguments, trebuie să fie literal $ARGUMENTS), (2) argumente din mai multe cuvinte fără ghilimele (/cmd hello world se împarte; /cmd "hello world" le păstrează împreună), (3) allowed-tools separat prin virgule în loc de spații, (4) fișierul de comandă nu se află în .claude/commands/ sau .claude/skills/, (5) sesiunea Claude Code trebuie reîncărcată după editarea fișierului.

$ARGUMENTS apare literal în promptul LLM

Simptom: Promptul tău afișează $ARGUMENTS ca text simplu în răspunsul modelului, ca și cum utilizatorul l-ar fi ignorat. Cauză: Capitalizare sau ortografie greșită. Tokenul este literalmente $ARGUMENTS, opt caractere, toate majuscule. Remediere: Deschide fișierul .md, caută cu grep $args, $ARGS, $arguments, ${ARGUMENTS}, înlocuiește cu $ARGUMENTS. Bug-ul cauzat de greșeala de tastare $args a afectat fiecare dezvoltator din echipa noastră cel puțin o dată; este bug-ul cu cel mai mare volum din familia „comandă slash necunoscută".

Argumentul format din mai multe cuvinte se divide în mod neașteptat

Simptom: Ai rulat /migrate-component Search Bar React Vue, iar $1 este Search, $2 este Bar. Cauză: Spațiile albe divid argumentele poziționale. Soluție: Pune între ghilimele argumentul format din mai multe cuvinte: /migrate-component "Search Bar" React Vue. Acum $1 este Search Bar. Aceasta corespunde comportamentului shell-ului, modelul mental pe care această utilizare îl reflectă în mod deliberat.

allowed-tools nu este respectat

Simptom: Comanda rulează, dar Claude refuză să apeleze instrumentele pe care credeai că le-ai trecut în lista albă sau apelează instrumente pe care nu le-ai enumerat. Cauză: Sunt separate prin virgulă în loc de spațiu. Remediere: Schimbă allowed-tools: Bash, Read, Edit în allowed-tools: Bash Read Edit. Pentru sub-tiparele instrumentelor, formatează ca Bash(git:*) Bash(npm:*) Read.

Comanda nu apare în autocompletarea /

Simptom: Tastați /, iar comanda nu apare în listă. Cauză: Locația fișierului, lipsa frontmatter-ului sau setarea incorectă a disable-model-invocation. Soluție: Verificați dacă fișierul se află la .claude/commands/yourcmd.md (sau .claude/skills/yourcmd/SKILL.md), relativ la rădăcina proiectului. Verificați dacă frontmatter-ul conține cel puțin câmpul description:. Dacă ați setat disable-model-invocation: true, comanda nu va fi vizibilă pentru ceilalți agenți, dar va apărea în continuare în meniul / accesat manual de utilizator.

Ai editat fișierul .md, dar nimic nu s-a schimbat

Simptom: Ai corectat bug-ul, ai salvat fișierul, ai rulat din nou comanda — același comportament defect. Cauză: Claude Code memorează în cache fișierele de comenzi la pornirea sesiunii. Soluție: Închide și redeschide Claude Code sau rulează /reload, dacă versiunea ta îl suportă.

Claude Code citește fișierele .md la pornirea sesiunii. Dacă editezi o comandă și aceasta „nu se schimbă", repornește sesiunea înainte să presupui un bug mai profund.

Pentru cazuri limită dincolo de aceste cinci, issues din repository-ul Claude Code sunt cel mai bun loc pentru căutare. Cele mai ciudate bug-uri de substituție pe care le-am întâlnit sunt, în general, o variantă a uneia dintre problemele de mai sus.

Întrebări frecvente: Argumente pentru comenzile Slash din Claude Code

Cum transmit argumente unei comenzi slash din Claude Code?

Tastați șirul de argumente după numele comenzii: /greet World. În fișierul .md al comenzii, referențiați valoarea ca $ARGUMENTS (întregul șir), $1 (primul argument pozițional) sau $variableName (dacă ați declarat arguments: [variableName] în frontmatter). Utilizatorul înlocuiește tokenul înainte de a trimite promptul către LLM.

Ce este $ARGUMENTS în Claude Code?

$ARGUMENTS este un token de substituție în fișierele de comenzi slash personalizate, pe care Claude Code îl înlocuiește cu întregul șir de argumente introdus de utilizator după numele comenzii. Dacă un utilizator rulează /deploy --staging --dry-run, atunci $ARGUMENTS devine șirul literal --staging --dry-run în promptul randat, înainte ca LLM-ul să îl vadă.

Pot comenzile slash din Claude Code să primească flaguri în stil CLI precum --json?

Nu în mod nativ, nu există un parser de flaguri pentru comenzile personalizate. Scrii --json în $ARGUMENTS, iar promptul tău instruiește LLM-ul să îl detecteze și să se comporte în consecință. Aceasta funcționează deoarece Claude este un parser flexibil pentru text structurat. Comenzile integrate precum /clear și /help chiar au flaguri reale, dar comenzile personalizate pe care le creezi funcționează după reguli bazate exclusiv pe substituție.

Care este diferența dintre $1, $ARGUMENTS și $name în Claude Code?

$1 este primul argument pozițional separat prin spații albe ($2 este al doilea și așa mai departe). $ARGUMENTS este întregul șir de argumente exact așa cum a fost dat, inclusiv toate componentele poziționale și orice opțiuni (flags). $name este un argument numit, declarat în câmpul arguments: [name] din frontmatter, util atunci când vrei sloturi poziționale auto-documentate, fără indexare numerică.

Cum funcționează argument-hint în Claude Code?

argument-hint este un câmp de frontmatter care controlează ceea ce meniul de autocompletare / afișează lângă numele comenzii tale. Setarea argument-hint: <issue-number> [--priority high] afișează exact acel șablon după ce utilizatorul tastează /. Ține strict de UX — nu validează și nu interpretează argumentele. Merită totuși să îl configurezi, pentru că este cea mai ieftină documentație pe care o vei scrie vreodată.

Cum creez o comandă slash personalizată cu mai multe argumente?

Două opțiuni elegante. Pentru argumente poziționale: referențiază $1, $2, $3 în corpul promptului. Pentru argumente numite: declară arguments: [first, second, third] în frontmatter și referențiază $first, $second, $third. Cele numite sunt mai ușor de citit pentru trei sau mai multe argumente. Folosește $ARGUMENTS doar când vrei ca LLM-ul să analizeze un șir liber, fără format fix, după sloturile poziționale obligatorii.

Este .claude/commands/ depreciat în favoarea .claude/skills/?

Nu. Anthropic a reunit cele două sisteme în primăvara anului 2026, dar a păstrat în mod explicit funcționarea fișierelor .claude/commands/*.md cu reguli de substituție identice. Folosiți comenzile pentru automatizări dintr-un singur fișier și skill-urile pentru pachete din mai multe fișiere (SKILL.md plus șabloane sau referințe). Același frontmatter, același comportament $ARGUMENTS, diferă doar modul de împachetare. Ambele sunt de prim rang începând cu v2.1.126.

De ce nu se substituie $ARGUMENTS în comanda mea?

Trei cauze principale, în ordinea frecvenței: eroare de capitalizare (trebuie să fie majuscule $ARGUMENTS, nu $args sau $arguments), locația greșită a fișierului (trebuie să se afle în .claude/commands/ sau .claude/skills/) sau sesiune expirată (Claude Code citește fișierele de comenzi la pornirea sesiunii, deci repornește după editare). Dacă toate trei sunt în regulă, rulează /echo-args foo cu exemplul minimal din H2 #1 pentru a izola problema.

Pot să cer anumite argumente?

Nu la nivel de utilizare — nu există o validare nativă a argumentelor obligatorii. Tiparul este să instruiți LLM-ul în prompt: „Dacă $1 este gol, oprește-te și spune utilizatorului să furnizeze un număr de problemă.” Modelul este cel care impune contractul. Nu este infailibil, dar în practică este suficient de fiabil pentru utilizarea zilnică, mai ales atunci când este însoțit de un argument-hint clar.

model: din frontmatter suprascrie flag-urile CLI?

Da, frontmatter-ul are prioritate. Dacă fișierul tău de comandă declară model: claude-haiku-4, acea comandă rulează pe Haiku indiferent de modelul pe care utilizatorul l-a selectat pentru sesiune. Acest lucru este util pentru comenzile ieftine, invocate frecvent, pe care vrei să le ții departe de Opus. Vezi ghidul nostru despre schimbarea modelelor Claude pentru a alege varianta potrivită pentru fiecare tip de comandă.

Încheiere

Patru tipare. Alege-l pe cel care se potrivește formei comenzii tale:

• Flag boolean (--dry-run), scrie-l în $ARGUMENTS și lasă LLM-ul să-l detecteze.
• Flag cu valoare (--filter <pattern>), aceeași abordare, LLM-ul extrage valoarea.
• Argument pozițional obligatoriu + flag opțional, $1 pentru cel obligatoriu, $ARGUMENTS pentru restul.
• Argumente poziționale stricte, $0/$1/$2 (sau denumite prin arguments:) când fiecare slot este obligatoriu și ordonat.

Acum că comenzile tale sunt parametrice, pasul următor este integrarea lor în fluxurile de lucru ale agentului — începe cu tutorialul nostru despre Claude Skills pentru upgrade-ul de împachetare multi-fișier sau răsfoiește instrumente alternative de codare AI dacă compari harness-uri. Oricum ar fi, folderul tău .claude/commands/ tocmai a devenit mult mai util.