Hooks v Claude Code 2026: nastavenie krok za krokom a 7 príkladov pripravených na použitie

Hooks v Claude Code sú shellové príkazy, volania HTTP alebo krátke kontroly LLM, ktoré sa automaticky spúšťajú pred akciou Clauda alebo po nej. Pridávajú kontroly konkrétnych udalostí nástrojov, formátujú kód po úprave a vkladajú kontext na začiatku relácie. Zodpovedajúci PreToolUse hook môže odmietnuť volanie; regexové príklady sú pomocné ochrany, nie bezpečnostná hranica každého súborového či Git prístupu. Nasleduje prehľad 4 typov obslužných prvkov, 31 udalostí životného cyklu, testu „kedy patrí pravidlo do hooku“, 7 hookov pripravených na skopírovanie do .claude/settings.json a 3 nástrah, na ktoré som narazil.

Dokumentácia Ailoot: API, kľúče a nastavenie.

Čo sú hooks v Claude Code?#

Pol roka som mal pravidlo „nikdy neupravovať .env priamo“ v CLAUDE.md. Claude ho porušil raz za mesiac. Nie zo zlého úmyslu; na konci dlhej relácie ho jednoducho zabudol. Raz sa do .env dostal token navyše; inokedy premenná s duplicitným názvom prepísala tú, ktorá sa používala.

Presunul som toto pravidlo do hooku, takže sa naň nedá zabudnúť. Ak zodpovedajúci priamy editačný nástroj dodá cestu .env, nastavený hook odmietne toto volanie. Presmerovanie Bash, skripty, MCP a ostatné cesty potrebujú samostatné opatrenia; príklad nerobí súbor nemenným.

Inými slovami, hook je váš príkaz, ktorý Claude Code spustí pri konkrétnej udalosti. Každá úprava súboru, spustenie Bash, začiatok relácie alebo dokončenie subagenta je udalosť, ku ktorej môžete pripojiť hook.

Prečo je to dôležité pre vibe codera:

• Chráňte súbory obsahujúce tajomstvá pred náhodnými úpravami.
• Automaticky spúšťajte prettier/eslint po každom vygenerovaní kódu.
• Blokujte git push --force do main bez výslovného povolenia.
• Vkladajte aktuálny kontext na začiatku každej relácie.
• Zaznamenávajte akcie Clauda na účely auditu.

CLAUDE.md spravuje kontext. Hooks spravujú akcie. Sú to dve odlišné veci a ich zamieňanie je hlavnou začiatočníckou chybou.

Čím sa hooks líšia od CLAUDE.md a skills?#

Dokumentácia Anthropic výslovne vysvetľuje rozdiel medzi CLAUDE.md a hooks:

Inak povedané: obsah CLAUDE.md sa dostane ku Claudovi ako prvá správa od používateľa, nie ako systémový pokyn. Model si ho prečíta a pokúsi sa ho dodržiavať. Neexistujú však žiadne záruky, najmä ku koncu dlhej relácie, keď sa kontext zväčší a staršie pokyny sa vytlačia.

Hook funguje inak. Nachádza sa v settings.json, nezávisí od modelu a proces Claude Code ho spustí pri konkrétnej udalosti: PreToolUse, PostToolUse, SessionStart a ďalších. Príkaz sa spustí skôr, než Claude dostane výsledok, a môže fyzicky zablokovať akciu (exit 2) alebo po úprave zmeniť súbor (exit 0).

Porovnanie:

Úplná šablóna CLAUDE.md a 6 pravidiel pre živý súbor sú v príručke Ako nakonfigurovať CLAUDE.md v roku 2026: pripravená šablóna a 6 pravidiel. O skills ako pomenovaných schopnostiach sa dozviete v článku Claude Code Skills: Ako si vytvoriť vlastnú knižnicu.

Hook je najnižšia úroveň: žiadny model, žiadna interpretácia, iba shell.

Hooks sú jedným z nástrojov kontextového inžinierstva, popri Plan Mode a /compact.

4 typy hookov: Command, HTTP, Prompt, Agent — ktorý si vybrať?#

Najčastejšou chybou je pokúšať sa pomocou Command urobiť to, na čo treba Prompt. Napríklad „nepoužívaj pomlčky em dash v súboroch .md“ je úloha pre grep, takže Command je ideálny. Ale „nepíš korporátnym tónom“ je sémantické pravidlo, preto potrebuje Prompt.

Ak práve začínate, použite Command. Všetkých 7 hotových hookov nižšie je typu Command. HTTP/Prompt/Agent prídu na rad neskôr, keď budete pripravení.

Kde je settings.json a aké sú 4 úrovne konfigurácie?#

Všetkých 7 opísaných hookov uchovávam v projektovom súbore .claude/settings.json, aby sa automaticky zahrnuli pri klonovaní repozitára a Claude dodržiaval rovnaké pravidlá v novom okne. Osobné experimentálne hooks patria do .claude/settings.local.json, aby tímu neprekážali.

Všetky 4 súbory sa zlúčia pri začiatku relácie. Ak sú pravidlá v konflikte, prednosť má nižšia úroveň (lokálna pred projektovou, projektová pred používateľskou).

Najrýchlejší spôsob, ako vytvoriť prvý hook, je interaktívna ponuka /hooks priamo v Claude Code. Vyberte udalosť zo zoznamu, zvoľte matcher (napríklad Bash alebo Edit) a vložte príkaz. Claude Code za vás zapíše platný JSON do settings.json.

31 udalostí životného cyklu: ktoré potrebujú začiatočníci?#

Je dôležité pochopiť tieto tri frekvencie, aby ste sa nezmýlili:

1. Raz za reláciu - SessionStart, SessionEnd, Setup. Spustia sa raz, keď sa Claude Code otvorí a zatvorí. Použite ich na inicializáciu kontextu a odstránenie dočasných súborov.
2. Raz za ťah - UserPromptSubmit, UserPromptExpansion, Stop, StopFailure. Spustia sa pri každej vašej správe a vždy, keď sa model zastaví. Použite ich na zaznamenávanie konverzácie a záverečné kontroly výsledkov.
3. Pri každom volaní nástroja - PreToolUse, PostToolUse, PostToolUseFailure, PermissionRequest, PermissionDenied, PostToolBatch, SubagentStart, SubagentStop. Spustia sa pri každej úprave súboru, spustení Bash, čítaní alebo vyhľadávaní. Toto je najhorúcejšia vrstva, v ktorej sa uplatňujú obmedzenia, formátovanie a validácie.

Úplný zoznam 31 udalostí obsahuje asynchrónne/reaktívne udalosti: TeammateIdle, PreCompact, PostCompact, Elicitation, ElicitationResult, InstructionsLoaded, ConfigChange, CwdChanged, FileChanged, WorktreeCreate, WorktreeRemove, Notification. Sú určené pre pokročilé scenáre; zatiaľ ich preskočte.

Test s piatimi otázkami: kedy patrí pravidlo do hooku a kedy zostáva v CLAUDE.md?#

Pre mňa je to zákon, nie návrh. Voľbu medzi CLAUDE.md a hookom som zredukoval na jednoduchý test s piatimi otázkami. Ak sú aspoň tri odpovede „áno“, pravidlo patrí do hooku. Pri menej než troch zostáva v texte.

Test „kedy patrí pravidlo do hooku?“:

1. Týka sa toto pravidlo akcie, a nie kontextu? („nespúšťaj rm -rf“ je akcia; „mám projekt TypeScript“ je kontext.)
2. Týka sa toto pravidlo bezpečnosti, peňazí alebo údajov? („nedotýkaj sa .env“, „nezverejňuj kľúče“.)
3. Dá sa skontrolovať pomocou grep, regex alebo návratového kódu shellového príkazu? („po úprave .md skontroluj, či v ňom nie je pomlčka em dash“.)
4. Bolo by bolestivé napraviť následky porušenia pravidla? („force push do main“ sa ťažko napravuje; „zabudnutá bodka na konci“ ľahko.)
5. Už ste videli, že Claude toto pravidlo aspoň raz zabudol?

Príklad: „Nepoužívaj pomlčky em dash; používaj iba spojovníky.“ Akcia? Áno. Bezpečnosť? Nie. Dá sa skontrolovať grepom? Áno. Ťažko sa to napravuje? Nie. Videli ste porušenie? Áno. 3 z 5: dajte to do hooku.

Protipríklad: „Mám vibe coderov, nie developerov; píš bez slangu.“ Akcia? Skôr kontext. Bezpečnosť? Nie. Dá sa skontrolovať regexom? Príliš ťažko. Ťažko sa to napravuje? Nie. Videli ste porušenie? Áno. 1 z 5: nechajte to v CLAUDE.md.

Päť mojich pravidiel testom prešlo. Presunuli sa do hookov. Zvyšných 75% zostalo v textovom súbore.

7 hookov pripravených na skopírovanie#

Všetkých 7 hookov je uložených v jednom súbore .claude/settings.json v koreňovom priečinku projektu. Každá položka obsahuje typ udalosti, filter nástroja (matcher) a shellový príkaz. Kód 2 odmieta zodpovedajúce PreToolUse volanie pred vykonaním. Pri PostToolUse už akcia prebehla: hook poskytuje spätnú väzbu a nemôže ju vrátiť.

exit 0 znamená úspech. exit 1 znamená chybu, ale Claude pokračuje (to je prvý antipattern nižšie). exit 2 závisí od udalosti: môže blokovať PreToolUse, zatiaľ čo PostToolUse iba hlási spätnú väzbu k už vykonanej akcii.

Hook 1. Kontrola priamych úprav .env (PreToolUse, exit 2)

Blokuje pokusy o priame úpravy akéhokoľvek súboru zodpovedajúceho .env, .env.local, .env.production a podobne.

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write|MultiEdit",
        "hooks": [
          {
            "type": "command",
            "command": "FILE=$(jq -r '.tool_input.file_path // empty'); [ -z \"$FILE\" ] && exit 0; echo \"$FILE\" | grep -qE '(^|/)\\.env(\\.|$)' && { echo 'Do not edit `.env` directly. Tell me which variable to add, and I’ll open the file myself.' >&2; exit 2; } || exit 0"
          }
        ]
      }
    ]
  }
}

Čo robí: Pred každým Edit/Write/MultiEdit získa cestu k súboru, pomocou grep skontroluje, či zodpovedá vzoru .env, a ak áno, vráti exit 2 so správou. Claude vidí stderr a povie mi: “I tried to edit .env, but the hook blocked me; tell me which variable to add.”

Hook 2. Automatické spustenie prettier po každej úprave kódu (PostToolUse, exit 0)

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write|MultiEdit",
        "hooks": [
          {
            "type": "command",
            "command": "FILE=$(jq -r '.tool_input.file_path // empty'); [ -z \"$FILE\" ] && exit 0; echo \"$FILE\" | grep -qE '\\.(ts|tsx|js|jsx|json)$' && npx prettier --write \"$FILE\" 2>/dev/null & exit 0"
          }
        ]
      }
    ]
  }
}

Čo robí: Po každom Edit/Write získa cestu a ak je prípona .ts/.tsx/.js/.jsx/.json, spustí prettier na pozadí pomocou &. Vždy vráti 0, pretože ide o formátovanie, nie obmedzenie. Ak prettier zlyhá, nič sa nedeje; súbor zostane tak, ako bol.

Rozdiel oproti hooku 1 je zásadný: PreToolUse + exit 2 je tvrdé blokovanie pred akciou. PostToolUse + exit 0 je mierna úprava po akcii. Ide o dva odlišné režimy pre rôzne úlohy.

Hook 3. Blokovanie git push --force do vetvy main (PreToolUse, exit 2)

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "CMD=$(jq -r '.tool_input.command // empty'); [ -z \"$CMD\" ] && exit 0; echo \"$CMD\" | grep -qE 'git[[:space:]]+push' && echo \"$CMD\" | grep -qE '(\\-\\-force|\\-\\-force-with-lease|[[:space:]]-f([[:space:]]|$))' && echo \"$CMD\" | grep -qE '([[:space:]/:])main([[:space:]/:]|$)' && { echo 'Force push to main is forbidden. Create a new branch or ask me to do it manually.' >&2; exit 2; } || exit 0"
          }
        ]
      }
    ]
  }
}

Čo robí: Pri každom spustení Bash kontroluje, či príkaz obsahuje push, obsahuje --force/--force-with-lease/-f a spomína main. Ak sa zhodujú všetky tri podmienky, zablokuje ho jasnou správou.

Kedysi som mal toto pravidlo v CLAUDE.md napísané veľkými písmenami. Claude ho aj tak porušil približne raz za dva týždne, keď som ho požiadal o „force push, aby som vrátil svoj zlý commit“. Hook zachytáva uvedené doslovné tvary, no aliasy, skripty, implicitná cieľová vetva či iný klient Gitu môžu kontrolu obísť. Na vzdialenom serveri vynucujte ochranu main a obmedzte dostupné prihlasovacie údaje agenta.

Hook 4. Blokovanie pomlčiek em dash v textových súboroch (PostToolUse, exit 2)

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write|MultiEdit",
        "hooks": [
          {
            "type": "command",
            "command": "FILE=$(jq -r '.tool_input.file_path // empty'); [ -z \"$FILE\" ] && exit 0; echo \"$FILE\" | grep -qE '\\.(md|mdx|tsx?)$' && grep -q $'\\xe2\\x80\\x94' \"$FILE\" && { echo \"File $FILE contains an em dash (U+2014). Replace it with a regular hyphen (U+002D).\" >&2; exit 2; } || exit 0"
          }
        ]
      }
    ]
  }
}

Čo robí: PostToolUse s exit 2 hlási zlyhanie následnej kontroly Claude po úprave. Zápis nevracia ani mu nebráni. Ak Claude upraví súbor a ponechá v ňom pomlčku em dash, hook zlyhá, Claude dostane spätnú väzbu a skúsi to znova. Po 2–3 reláciách Claude prestane tento znak úplne vkladať.

Všimnite si, že grep hľadá konkrétne znak pomlčky em dash (U+2014) pomocou $'\xe2\x80\x94', čo je zápis v Bash na jeho vyjadrenie v bajtoch UTF-8. Ak jednoducho napíšete grep -q '-', zachytí aj obyčajné spojovníky a spustí sa pri každom súbore. Neviditeľný znak pokazí celú logiku.

Hook 5. Uvoľnenie portu 3000 pred npm run dev (PreToolUse, exit 0)

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "CMD=$(jq -r '.tool_input.command // empty'); [ -z \"$CMD\" ] && exit 0; echo \"$CMD\" | grep -qE '(npm|pnpm|yarn)[[:space:]]+run[[:space:]]+dev' && { lsof -ti:3000 | xargs -r kill -9 2>/dev/null; echo 'Port 3000 freed before launch' >&2; }; exit 0"
          }
        ]
      }
    ]
  }
}

Čo robí: Pred každým npm run dev (alebo pnpm/yarn) ukončí proces na porte 3000. Vždy vráti 0, pretože ide o prípravu, nie obmedzenie. Chráni tak pred situáciou, keď Claude vidí „port sa používa“, myslí si, že je problém v kóde, a začne opravovať veci, hoci starý server iba zostal spustený.

Hook 6. Automatický commit po úspešných tests (PostToolUse, exit 0)

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "INPUT=$(cat); CMD=$(printf '%s' \"$INPUT\" | jq -r '.tool_input.command // empty') || exit 1; EXIT=$(printf '%s' \"$INPUT\" | jq -r '.tool_response.exit_code // empty') || exit 1; case \"$CMD\" in 'npm test'|'pnpm test'|'yarn test') ;; *) exit 0 ;; esac; [ \"$EXIT\" = \"0\" ] || exit 0; git diff --cached --quiet || { echo 'Existing staged changes: review manually' >&2; exit 0; }; git add -- src/orders.ts tests/orders.test.ts || exit 1; git diff --cached --quiet && exit 0; git commit -m 'tests: checkpoint after successful run'"
          }
        ]
      }
    ]
  }
}

Čo robí: stdin JSON číta raz a prijíma iba uvedené presné jednoduché testovacie príkazy. Pokračuje len pri výslovne nulovom tool_response.exit_code; ak verzia toto pole neposkytuje, commit vynechá namiesto hádania úspechu. src/orders.ts a tests/orders.test.ts nahraďte presnými súbormi vlastnenými úlohou. Existujúci staging postup zastaví proti zahrnutiu cudzej práce. Neúspešné pridanie zastaví, prázdny diff necommituje a bežné commit hooky zostávajú zapnuté. Pred zapnutím otestujte úspešný, neúspešný a chýbajúci výsledok offline.

Antipattern: pridávať git commit --no-verify ku každému Edit. Kontroly commitov nechajte zapnuté. Pri rekurzii zúžte spúšťač alebo prerobte kontrolu; overenie predvolene neobchádzajte. Pred automatickými commitmi posúďte pripravený diff a vlastníctvo úlohy.

Hook 7. Vloženie aktuálneho kontextu na začiatku relácie (SessionStart s additionalContext)

{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "*",
        "hooks": [
          {
            "type": "command",
            "command": "BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null || echo 'no-branch'); STATUS=$(git status --short 2>/dev/null | head -10); echo \"{\\\"additionalContext\\\":\\\"Current branch: $BRANCH. Uncommitted changes:\\n$STATUS\\\"}\""
          }
        ]
      }
    ]
  }
}

Čo robí: Na začiatku relácie získa aktuálnu vetvu Git a zoznam nezaznamenaných zmien, potom vráti JSON s poľom additionalContext. Claude Code vloží tento text do prvej systémovej správy, takže Claude od začiatku vie, kde sa nachádza a čo zostalo z predchádzajúcej relácie.

Rozšírenia tohto hooku: načítať najnovší commit a jeho opis, stav GitHub Actions, aktívny sprint z Linear/Jira a otvorené issues pre aktuálny repozitár.

3 nástrahy hookov, na ktoré narazí každý druhý#

Nástraha 1. Hook s exit 1 prejde bez upozornenia

Najnebezpečnejšia z nich. Týždeň som si myslel, že ochrana .env funguje, ale ukázalo sa, že som mal v hooku jq -r '.tool_input.file_path' bez kontroly na null. Keď bol tool_input prázdny, jq skončil s kódom 1. Claude považoval exit 1 za „chyba hooku, pokračovať“, takže akcia prebehla. Nechápal som, prečo sa .env stále upravuje. Príčinu som zistil až vtedy, keď som hook spustil ručne v termináli s prázdnym vstupom.

Riešenie je jedno pravidlo: každý hook začnite kontrolou na null a ukončite ho pomocou || exit 0. Každý neočakávaný výstup potom spôsobí „bezpečné“ ukončenie namiesto tichého prejdenia.

# Safe start and end template:
FILE=$(jq -r '.tool_input.file_path // empty')
[ -z "$FILE" ] && exit 0
# ... your logic ...
exit 0   # or || exit 0 on one line

Nástraha 2. Pomalé hooks sa ukončia po timeoute

Mal som hook, ktorý po Edit spustil eslint --fix na celom súbore. Spracovanie veľkých súborov (1000+ riadkov) trvalo 8–10 sekúnd. Predvolený timeout hooku v Claude Code je 60 sekúnd, takže som si myslel, že som v limite. Keď sa však v priebehu jednej minúty vykoná viacero úprav Edit, hooks sa hromadia a čakajú vo fronte a niektoré sa jednoducho preskočia. Uvedomil som si to až vtedy, keď sa v zázname objavilo „hook timed out“.

Riešenie: ak hook vyžaduje náročnú prácu, spustite ju na pozadí. eslint --fix "$FILE" & bez čakania na výsledok. Hook potom vráti exit 0 v priebehu milisekúnd, zatiaľ čo skutočná práca beží na pozadí.

# Heavy operation in background:
npx eslint --fix "$FILE" &
exit 0

Nástraha 3. Hook nevidí premenné prostredia projektu

Myslel som si, že process.env bude v hooku dostupné rovnako ako v aplikácii Node.js. Nie je to tak. Hook beží v shelli spustenom nadradeným procesom Claude Code a vidí iba to, čo je v ~/.zshrc alebo ~/.bashrc, plus to, čo mu Claude Code výslovne odovzdá. Ak hook závisí od OPENAI_API_KEY z .env, budete musieť .env načítať ručne.

Riešenie: načítajte .env priamo v príkaze hooku.

# Passing project env into hook:
cd "$PWD" && source .env && curl -H "Authorization: Bearer $OPENAI_API_KEY" ...
# Or with dotenv:
dotenv -e .env -- node my-validator.js

Je to obzvlášť nepríjemné v monorepe, kde majú rôzne balíky vlastné súbory .env. Vyriešte to odovzdaním PWD a výslovným spustením cd "$PWD" na začiatku príkazu.

Ako otestovať hooks pred commitom?#

Základný testovací scenár. Vezmite príkaz hooku z JSON, otvorte terminál a zadajte mu JSON, ktorý by poslal Claude Code:

# Test hook 1 (protect .env):
echo '{"tool_input":{"file_path":".env"}}' | bash -c '
FILE=$(jq -r ".tool_input.file_path // empty")
[ -z "$FILE" ] && exit 0
echo "$FILE" | grep -qE "(^|/)\.env(\.|$)" && {
  echo "BLOCKED" >&2
  exit 2
} || exit 0
'
echo "Exit code: $?"

V stderr by ste mali vidieť BLOCKED a Exit code: 2. Ak dostanete exit 0, váš regex nefunguje; opravte grep.

Scenáre na kontrolu:

1. Pozitívna cesta - súbor sa má zablokovať. .env pre hook 1, git push --force main pre hook 3.
2. Negatívna cesta - súbor sa nemá zablokovať. README.md pre hook 1, git push origin feature-branch pre hook 3.
3. Hraničné prípady - prázdny vstup, hodnoty null, neočakávané znaky. Hook má buď vrátiť exit 0, alebo zlyhať s jasnou chybou, nie potichu prejsť.

Kam umiestniť experimentálne hooks. Nie do .claude/settings.json, ale do .claude/settings.local.json (nie je v gite). Pridajte tam nové hooks pod PostToolUse s príkazom echo namiesto skutočnej akcie, skontrolujte, či sa spúšťajú, a potom ich presuňte do produkčného settings.json.

// Experiment in settings.local.json - writes to /tmp/hook-debug.log:
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [
          {
            "type": "command",
            "command": "echo \"[hook fired] $(date) $(jq -r '.tool_input.file_path // \"?\"')\" >> /tmp/hook-debug.log"
          }
        ]
      }
    ]
  }
}

Po 5–10 úpravách v Claude Code otvorte /tmp/hook-debug.log a zistite, ktoré súbory hook spustili. Ak je prázdny, matcher nesedí; opravte regex.

Čo ďalej?#

5 krokov na nasledujúci týždeň:

1. Vyhľadajte v CLAUDE.md slová ako „nikdy“, „zakázané“, „vždy“ a „musí“. Každé také pravidlo je kandidátom na hook. Ak je pravidlo príkazové, textový súbor ho nevynúti.
2. Začnite s PostToolUse + exit 0. Sú najbezpečnejšie: vykonajú zmenu, ale nič neblokujú. Prettier (hook 2), ukončenie vývojového servera (hook 5), automatický commit po tests (hook 6).
3. Až keď si budete istí, pridajte prvý PreToolUse + exit 2. Napríklad ochranu .env (hook 1) alebo zabránenie force-push (hook 3). Ide o tvrdé blokovanie a chyba v príkaze grep môže zablokovať aj vás.
4. Pred commitom otestujte hooks ručne (pozrite si časť vyššie). Ušetrí vám to hodiny ladenia.
5. Nechajte si settings.local.json na experimenty. Pridávajte tam nové hooks s príkazom echo namiesto skutočnej akcie.

Keď nakonfigurujete hooks, ďalším krokom v sérii je ako vrátiť zmeny v Claude Code, keby hook prepustil niečo nebezpečné. Ak chcete, aby si Claude pamätal štruktúru projektu medzi reláciami, vytvorte Druhý mozog v Claude Code (priečinok business/ + prepojená znalostná báza). A ak chcete pomenovať skills svojho projektu, aby sa dali znovu použiť, pozrite si Claude Code Skills.

Ak potrebujete prístup k neurónovým sieťam cez Ailoot, pozrite si Ailoot.