Kurs vibe coding z Claude Code · Moduł 15: Claude Code dla zaawansowanych

Siatka dla pracy bez nadzoru: tryb auto, reguły deny i sandbox

9 min czytania
W tej lekcji9

Trasy API Treasure Map zgłaszają błędy każda po swojemu: sześć plików, piętnaście ręcznie pisanych Response.json({ error: ... }), a testy mają tylko dwie trasy. Przeniesienie ich na wspólny moduł lib/apiErrors.ts i dopisanie brakujących testów to godzina mechanicznej pracy, w sam raz na wieczór, gdy Ty schodzisz z pokładu. Tylko że przez tę godzinę nikt nie kliknie "Yes". W trybie Manual przebieg stanie przy pierwszym pytaniu, a w bypassPermissions nie zatrzyma się przed niczym. Potrzebujesz trzeciej drogi: granic, których pilnuje program, a nie Twoja obecność przy klawiaturze.

Co już umiesz

Tryby uprawnień i Shift+Tab znasz z lekcji 0_4, a Esc, /rewind i commit jako kotwicę z lekcji 0_6. W lekcji 8_4 zamknąłeś .env regułą deny i poznałeś jej granice, w lekcji 10_5 usłyszałeś, że klasyfikator trybu auto blokuje wdrożenia produkcyjne, a w lekcji 12_4, że bypassPermissions ma sens tylko w kontenerze. Z lekcji 9_2 znasz worktree i claude -w, z lekcji 14_1 przebiegi claude -p i pole permission_denials, a z lekcji 14_3 i 14_5 kolejność deny, ask, allow i hook PreToolUse. Dziś składasz z tych lin jedną siatkę na wachtę bez kapitana.

Kto pilnuje, gdy Ciebie nie ma

Każde wywołanie narzędzia przechodzi przez stałą kolejkę. Najpierw Twoje reguły deny, ask i allow oraz hooki PreToolUse, potem odczyty i edycje plików w katalogu projektu, które tryb auto przepuszcza od razu, a wszystko inne trafia do klasyfikatora. Sandbox stoi za tą kolejką i ogranicza komendę shella już w trakcie jej działania.

WarstwaKto pilnujeCzego nie złapie
reguła deny albo ask, hookClaude Code, za każdym razem tak samokomendy zapisanej inaczej niż wzorzec, skryptu, który sam otwiera plik
klasyfikator trybu autoosobny modelmoże się pomylić w obie strony
sandboxsystem operacyjnynarzędzi plikowych Claude, serwerów MCP i hooków
commit i worktreeGitniczego nie zatrzymuje, ale pozwala cofnąć każdą zmianę w plikach

Żadna warstwa nie wystarcza sama, bo każda ma dziurę, którą łata następna. Na wachtę bez kapitana rozwieszasz wszystkie cztery.

Klasyfikator z bliska

Lista domyślnych blokad jest dłuższa niż wdrożenia z lekcji 10_5. Klasyfikator zatrzymuje między innymi pobranie i uruchomienie obcego kodu (curl | bash), force push, nieodwracalne kasowanie plików, które istniały przed sesją, komendy w rodzaju git reset --hard, które mogłyby wyrzucić niezacommitowaną pracę, wysyłkę wrażliwych danych na zewnątrz i uruchomienie innego agenta bez zgód i bez sandboxa. Przepuszcza za to operacje na plikach w katalogu projektu, instalację zależności z pliku blokady, push na każdą gałąź Twojego repozytorium, także na main, i odczyt .env. Całą listę wypisze komenda:

claude auto-mode defaults

Komenda niczego nie zmienia, tylko drukuje reguły jako JSON, każdą zwykłym zdaniem po angielsku. Przeczytaj ją raz, zanim zaufasz trybowi auto na noc. Pamiętaj przy tym o kolejce z początku lekcji: odczyt .env w katalogu projektu nie trafia nawet do klasyfikatora, bo tryb auto przepuszcza takie odczyty od razu, więc jedyną zaporą zostaje Twoja reguła deny.

Ważniejsze od listy jest to, co dzieje się po blokadzie. W sesji, przy której siedzisz, zablokowana akcja trafia do zakładki Recently blocked w /permissions, a po trzech blokadach z rzędu albo dwudziestu w sumie tryb auto się wstrzymuje i Claude Code znowu pyta Ciebie. W przebiegu claude -p nie ma kogo zapytać, więc dokumentacja mówi wprost: akcja się nie wykonuje, Claude pracuje dalej, a przebieg się nie zatrzymuje. Rano zobaczysz ją tylko w permission_denials.

Klasyfikator konfiguruje blok autoMode: zwykłe zdania o zaufanej infrastrukturze (environment) i wyjątkach (allow). Claude Code czyta go tylko z ~/.claude/settings.json, z ustawień organizacji i z flagi --settings, a z .claude/settings.json projektu nie, żeby sklonowane repozytorium nie poluzowało sobie zasad samo. Klasyfikator czyta za to CLAUDE.md, więc zdanie "nigdy nie rób force push" steruje i Claude, i oceną. Dla Treasure Map niczego tu nie dopisujesz, bo domyślne reguły pasują do projektu na jednym komputerze. Zapamiętaj ostrzeżenie z dokumentacji: tryb auto zmniejsza liczbę pytań, ale nie gwarantuje bezpieczeństwa. To, czego nie wolno nigdy, zapisujesz regułą.

Polecenie dla Claude Code

Nocny przebieg dostanie własny plik ustawień, podawany flagą --settings, więc Twoje dzienne sesje zostaną takie jak dotąd. W sesji w folderze treasure-map napisz:

Przygotuj ustawienia nocnej wachty. Utwórz scripts/nocna-wachta.json tylko dla
przebiegów bez nadzoru: sandbox włączony, bez ponawiania komend poza sandboxem,
sieć tylko do registry.npmjs.org, bez wyjątków. W .claude/settings.json dopisz do deny regułę
Bash(npx prisma migrate reset *), niczego nie usuwaj. Pokaż diff obu plików.
Bez commita, sprawdzę je sam.

Polecenie mówi, który plik powstaje, co ma w nim stać i czego nie ruszać, więc Claude nie ma czego zgadywać.

Co napisał Claude

Otwórz w Cursorze scripts/nocna-wachta.json. Cały plik to jeden klucz sandbox:

{
  "sandbox": {
    "enabled": true,
    "allowUnsandboxedCommands": false,
    "network": {
      "allowedDomains": ["registry.npmjs.org"],
      "strictAllowlist": true
    }
  }
}

enabled włącza sandbox, czyli granicę, którą dla komend shella stawia system operacyjny: na macOS mechanizm Seatbelt, na Linuksie i w WSL2 bubblewrap, a na natywnym Windowsie sandbox nie działa wcale. Komendy piszą wtedy tylko w katalogu roboczym i w katalogu tymczasowym, a do sieci wychodzą przez pośrednika, który sprawdza domeny z allowedDomains. Jedna wystarczy, bo świeży worktree potrzebuje npm install. strictAllowlist: true zamyka furtkę: bez niego w trybie auto Claude może dopisać do komendy dodatkową domenę, a klasyfikator ją zatwierdzić, a z nim pośrednik odmawia każdej domenie spoza listy, w każdym trybie. Ten klucz działa z flagi --settings i z ustawień użytkownika, z pliku projektu nie. Czytać mogą jednak prawie cały dysk, także ~/.ssh, i dlatego zamknięta sieć jest tu najważniejsza: przeczytany klucz nie ma dokąd wyjść. allowUnsandboxedCommands: false to tryb ścisły, w którym Claude nie może ponowić odrzuconej komendy poza sandboxem. W zwykłej sesji ten sam sandbox włącza /sandbox z lekcji 12_4, który zapisuje wybór w .claude/settings.local.json; plik podany flagą działa tylko na jeden przebieg.

W .claude/settings.json zmieniła się jedna linia:

    "deny": ["Read(./.env)", "Read(./.env.*)", "Bash(npx prisma migrate reset *)"]

Reset czyści całą bazę deweloperską, a agent sięga po niego, gdy historia migracji przestaje mu się zgadzać. Reguła ask z lekcji 14_3 też go obejmowała, ale deny nie pyta wcale i działa w każdym trybie. Spacja przed gwiazdką sprawia, że reguła łapie reset z każdą opcją, także z --force.

Start wachty: commit, worktree, limity

Zanim wypłyniesz, poproś Claude o commit, na przykład "Nocna wachta: sandbox i deny dla resetu bazy". To nie formalność. Worktree jest świeżym checkoutem zacommitowanych plików, a Claude Code czyta .claude/settings.json z katalogu, w którym pracuje sesja. Gdy projekt ma zdalne repozytorium, dochodzi push, jak w lekcji 9_2, bo worktree startuje wtedy od gałęzi z remote'a. Sprawdziliśmy to: przy niezacommitowanym .claude/ przebieg claude -p --worktree zapisał nowy plik w prisma/migrations/, bo hooka z lekcji 14_5 w worktree po prostu nie było. Dopiero po commicie start wygląda tak:

claude -p "Przenieś obsługę błędów we wszystkich trasach app/api na nowy moduł lib/apiErrors.ts i dopisz testy tras, które ich nie mają. Zacznij od npm install. Na koniec uruchom npm run test -- --run i npx tsc --noEmit, wypisz ich wynik i zrób commit." \
  --worktree api-bledy --permission-mode auto --settings scripts/nocna-wachta.json \
  --max-turns 40 --output-format json > nocny-raport.json

--worktree api-bledy zakłada katalog .claude/worktrees/api-bledy/ na gałęzi worktree-api-bledy, a Claude Code blokuje w nim edycje i komendy wycelowane w główny katalog. --permission-mode auto jest potrzebne, bo -p startuje w trybie Manual. --max-turns 40 to twardy hamulec: przebieg, który dobije do limitu, kończy się błędem; podobnie działa --max-budget-usd. Plik .env nie trafia do worktree i tak ma zostać, bo testy tras mockują @/lib/prisma. Po rejsie worktree sprzątasz sam komendą git worktree remove, bo -p nie pyta o to przy wyjściu. U nas git worktree list pokazał go po przebiegu jako locked, a zablokowanego worktree git nie usunie, dopóki nie wpiszesz git worktree unlock.

Czego /rewind nie odda po nocy

Checkpoint powstaje przed każdym poleceniem, które wysyłasz Ty, więc godzina pracy po jednym poleceniu ma jeden punkt powrotu: sprzed startu. Do tego granice z lekcji 0_6 rosną w nocy. Pliki zmienione wyłącznie komendą, jak package-lock.json po npm install, nie są śledzone. Edycji subagentów w tle /rewind zwykle nie przywraca, a zmian z innych sesji pracujących równolegle zwykle nie widzi. Dlatego kotwicą długiego rejsu jest Git: git diff main...worktree-api-bledy pokaże każdą zmianę, obojętnie którym narzędziem zrobioną, a gdy noc pójdzie źle, usuwasz worktree z gałęzią, a main stoi nietknięty.

Przegląd kapitana

  1. Commit przed startem. git status --short nie pokazuje .claude/ ani scripts/nocna-wachta.json jako niezacommitowanych. Inaczej worktree wypłynie bez Twoich reguł i hooków.
  2. Sandbox naprawdę działa. Dokumentacja podaje próbę: w sesji uruchomionej z tym samym --settings poproś Claude o touch ~/sandbox-probe i curl --noproxy '*' https://example.com. Pierwsza ma skończyć się Operation not permitted na macOS albo Read-only file system na Linuksie, druga Could not resolve host. U nas zwykły curl do example.com dostał CONNECT tunnel failed, response 403, a sandbox dopisał deny network-outbound example.com:443.
  3. ask bez Ciebie to odmowa. W naszym przebiegu -p komenda npx prisma migrate --help trafiła na regułę ask i dostała "Claude requested permissions to use Bash, but you haven't granted it yet.", a przebieg i tak skończył się sukcesem. Rano czytasz więc permission_denials, a nie sam kod wyjścia.
  4. autoMode w pliku projektu nie działa. Jeśli Claude dopisał ten blok do .claude/settings.json, Claude Code go zignoruje.

Typowy błąd agenta: gdy prosisz, żeby przebieg "nie stawał na pytaniach", Claude dla wygody proponuje --dangerously-skip-permissions albo "defaultMode": "bypassPermissions". Rozpoznasz to po tej fladze w komendzie albo po tym kluczu w diffie. Ten tryb zatwierdza wszystko, czego nie łapią reguły, także zapis do .git, a klasyfikatora w nim nie ma. Na Twoim laptopie nie ma dla niego miejsca, jak mówiła lekcja 12_4, a z pliku projektu i tak nie zadziała: sesja wystartuje w trybie Manual.

Następny krok

Zanim zostawisz wachtę na godzinę, zrób próbny rejs: ta sama komenda z --max-turns 5. Potem odczytaj raport:

jq '{subtype, is_error, num_turns, odmowy: [.permission_denials[].tool_input]}' nocny-raport.json

jq wybiera z raportu cztery pola: wynik, flagę błędu, liczbę tur i listę odrzuconych wywołań. Każda odmowa to pytanie do Ciebie: czy to była granica, którą chciałeś postawić, czy przeszkoda, przez którą zadanie stanie w pół drogi. Gdy próba wyjdzie czysto, usuń próbny worktree razem z jego gałęzią, żeby pełny rejs zaczął od czystej kopii:

git worktree unlock .claude/worktrees/api-bledy
git worktree remove --force .claude/worktrees/api-bledy
git branch -D worktree-api-bledy

Najpierw zdejmujesz blokadę, którą zostawił przebieg -p. --force jest potrzebne, bo po pięciu turach w worktree zwykle leżą niezacommitowane zmiany, a -D, bo gałąź nie została scalona i zwykłe -d odmówi. Potem puść pełny rejs z --max-turns 40. W następnej lekcji przebieg dostanie sprawdzian, który musi zaliczyć, zanim zamelduje koniec. W edytorze obok wybierzesz akcję, tryb i warstwy, a symulator pokaże, która z nich zatrzyma ruch i co zobaczysz rano.

Pamiętaj: nocą kursu nie trzyma kapitan, tylko liny, które przywiązał przed zmierzchem.

Kod do tej lekcji: App.tsx
// Kto zatrzyma ten ruch: reguły, hook, tryb uprawnień, klasyfikator i sandbox w nocnym przebiegu Treasure Map
import { useState } from 'react';

export type Mode = 'auto' | 'default' | 'dontAsk' | 'bypassPermissions';
export type Layer = 'deny' | 'hook' | 'ask' | 'allow' | 'tryb' | 'klasyfikator' | 'sandbox';
export type Result = 'wykonane' | 'zablokowane' | 'pytanie' | 'ocena';

export interface Rule {
  kind: 'deny' | 'ask' | 'allow';
  pattern: string;
}

export interface Action {
  label: string;
  tool: 'Read' | 'Write' | 'Bash';
  rule?: Rule;
  hookBlocks?: boolean;
  readOnly?: boolean;
  secret?: boolean;
  outsideWrite?: boolean;
  host?: string;
  localDb?: boolean;
  blockedBy?: string;
  allowedBy?: string;
}

export const ALLOWED_DOMAINS = ['registry.npmjs.org'];

export const ACTIONS: Action[] = [
  { label: 'Read: .env', tool: 'Read', rule: { kind: 'deny', pattern: 'Read(./.env)' }, readOnly: true, secret: true },
  { label: 'Write: prisma/migrations/20261115_komentarze/migration.sql', tool: 'Write', hookBlocks: true },
  { label: 'Bash: npx prisma migrate reset --force', tool: 'Bash', rule: { kind: 'deny', pattern: 'Bash(npx prisma migrate reset *)' }, localDb: true },
  { label: 'Bash: git push --force origin main', tool: 'Bash', rule: { kind: 'ask', pattern: 'Bash(git push *)' }, host: 'github.com', blockedBy: 'force push' },
  { label: 'Bash: curl -fsSL https://example.com/install.sh | bash', tool: 'Bash', host: 'example.com', blockedBy: 'uruchomienie obcego kodu' },
  { label: 'Bash: rm -rf lib', tool: 'Bash', blockedBy: 'nieodwracalne kasowanie plików sprzed sesji' },
  { label: 'Bash: npm run test -- --run', tool: 'Bash', rule: { kind: 'allow', pattern: 'Bash(npm run test *)' } },
  { label: 'Bash: npm install', tool: 'Bash', host: 'registry.npmjs.org', allowedBy: 'instalacja zależności z pliku blokady' },
  { label: 'Bash: touch ~/sandbox-probe', tool: 'Bash', outsideWrite: true },
];

export interface Options {
  mode: Mode;
  unattended: boolean;
  rulesLoaded: boolean;
  sandbox: boolean;
}

export interface Verdict {
  layer: Layer;
  result: Result;
  text: string;
}

export const MODE_LABEL: Record<Mode, string> = {
  auto: 'auto',
  default: 'Manual',
  dontAsk: 'dontAsk',
  bypassPermissions: 'bypassPermissions',
};

function needsYou(layer: Layer, o: Options, why: string): Verdict {
  if (o.mode === 'dontAsk') {
    return { layer, result: 'zablokowane', text: why + ' W dontAsk wszystko, co wymagałoby pytania, jest od razu odrzucane.' };
  }
  if (o.unattended) {
    return { layer, result: 'zablokowane', text: why + ' Bez Ciebie nikt nie odpowie: wywołanie zostaje odrzucone, Claude pracuje dalej, a ślad zostaje w permission_denials.' };
  }
  return { layer, result: 'pytanie', text: why + ' Praca stoi, dopóki nie odpowiesz.' };
}

function classifierBlock(name: string, o: Options): Verdict {
  const after = o.unattended
    ? ' W claude -p akcja się nie wykonuje, Claude pracuje dalej, a odmowa trafia do permission_denials.'
    : ' Akcja trafia do Recently blocked w /permissions; po 3 blokadach z rzędu albo 20 w sumie tryb auto wraca do pytań.';
  return { layer: 'klasyfikator', result: 'zablokowane', text: 'Klasyfikator blokuje domyślnie: ' + name + '.' + after };
}

function sandboxStage(a: Action, o: Options): Verdict | null {
  if (a.tool !== 'Bash' || !o.sandbox) return null;
  if (a.outsideWrite) {
    return { layer: 'sandbox', result: 'zablokowane', text: 'System operacyjny odmawia zapisu poza katalogiem roboczym i tymczasowym: Operation not permitted na macOS, Read-only file system na Linuksie i w WSL2.' };
  }
  if (a.localDb) {
    return { layer: 'sandbox', result: 'zablokowane', text: 'Sandbox nie wpuszcza połączenia z bazą na localhost: na macOS bez allowLocalBinding, na Linuksie i w WSL2 wcale.' };
  }
  if (a.host && !ALLOWED_DOMAINS.includes(a.host)) {
    return { layer: 'sandbox', result: 'zablokowane', text: 'Pośrednik sandboxa odrzuca połączenie z ' + a.host + ': przy strictAllowlist domena spoza allowedDomains nie przejdzie w żadnym trybie, także w bypassPermissions.' };
  }
  return null;
}

export function decide(a: Action, o: Options): Verdict {
  const rule = o.rulesLoaded ? a.rule : undefined;
  if (rule && rule.kind === 'deny') {
    return { layer: 'deny', result: 'zablokowane', text: 'Reguła ' + rule.pattern + ' blokuje w każdym trybie, także w ' + MODE_LABEL[o.mode] + '.' };
  }
  if (o.rulesLoaded && a.hookBlocks) {
    return { layer: 'hook', result: 'zablokowane', text: 'Hook PreToolUse z lekcji 14_5 kończy się kodem 2, zanim narzędzie ruszy.' };
  }
  if (rule && rule.kind === 'ask') {
    return needsYou('ask', o, 'Reguła ' + rule.pattern + ' wymaga zgody w każdym trybie, także w auto i bypassPermissions.');
  }

  let layer: Layer = 'tryb';
  let result: Result = 'wykonane';
  let why = '';
  if (rule && rule.kind === 'allow') {
    layer = 'allow';
    why = 'Reguła ' + rule.pattern + ' zatwierdza komendę.';
  } else if (o.mode === 'bypassPermissions') {
    why = 'bypassPermissions zatwierdza wszystko, czego nie łapią reguły.';
  } else if (o.mode === 'auto') {
    if (a.tool !== 'Bash' && !a.outsideWrite) {
      why = 'Tryb auto przepuszcza odczyty i edycje w katalogu projektu bez pytania klasyfikatora.';
    } else if (a.blockedBy) {
      return classifierBlock(a.blockedBy, o);
    } else if (a.allowedBy) {
      layer = 'klasyfikator';
      why = 'Klasyfikator domyślnie przepuszcza: ' + a.allowedBy + '.';
    } else {
      layer = 'klasyfikator';
      result = 'ocena';
      why = 'Komendę ocenia klasyfikator. Nie ma jej na liście domyślnych blokad, ale to ocena modelu, a nie reguła.';
    }
  } else if (o.mode === 'default') {
    if (!a.readOnly) return needsYou('tryb', o, 'Tryb Manual bez pytania tylko czyta.');
    why = 'Tryb Manual przepuszcza odczyt.';
  } else {
    if (!a.readOnly) return needsYou('tryb', o, 'dontAsk przepuszcza tylko odczyty i to, co zatwierdzają reguły allow.');
    why = 'dontAsk przepuszcza odczyt w katalogu projektu.';
  }

  const boxed = sandboxStage(a, o);
  if (boxed) {
    if (result === 'ocena' && boxed.result === 'zablokowane') {
      return { ...boxed, text: 'Nawet jeśli klasyfikator przepuści komendę: ' + boxed.text };
    }
    return boxed;
  }
  const note = a.secret ? ' Bez reguły deny nic nie zatrzymuje odczytu sekretów.' : '';
  const inBox = a.tool === 'Bash' && o.sandbox ? ' Komenda działa wewnątrz sandboxa.' : '';
  return { layer, result, text: why + note + inBox };
}

export const LAYERS: Layer[] = ['deny', 'hook', 'ask', 'allow', 'tryb', 'klasyfikator', 'sandbox'];

const RESULT_CLASS: Record<Result, string> = {
  wykonane: 'text-emerald-400',
  zablokowane: 'text-rose-400',
  pytanie: 'text-amber-400',
  ocena: 'text-sky-400',
};

export default function App() {
  const [index, setIndex] = useState(0);
  const [mode, setMode] = useState<Mode>('auto');
  const [unattended, setUnattended] = useState(true);
  const [rulesLoaded, setRulesLoaded] = useState(true);
  const [sandbox, setSandbox] = useState(true);
  const action = ACTIONS[index];
  const verdict = decide(action, { mode, unattended, rulesLoaded, sandbox });

  return (
    <div className="min-h-screen space-y-4 bg-slate-950 p-4 text-slate-100">
      <h1 className="text-xl font-bold">Kto zatrzyma ten ruch?</h1>
      <div className="grid gap-3 text-sm md:grid-cols-2">
        <label className="block">
          Akcja{' '}
          <select className="rounded bg-slate-800 p-1 font-mono" value={index} onChange={(e) => setIndex(Number(e.target.value))}>
            {ACTIONS.map((a, i) => (
              <option key={a.label} value={i}>{a.label}</option>
            ))}
          </select>
        </label>
        <label className="block">
          Tryb{' '}
          <select className="rounded bg-slate-800 p-1" value={mode} onChange={(e) => setMode(e.target.value as Mode)}>
            {(Object.keys(MODE_LABEL) as Mode[]).map((m) => (
              <option key={m} value={m}>{MODE_LABEL[m]}</option>
            ))}
          </select>
        </label>
      </div>
      <div className="space-y-1 text-sm">
        <label className="flex items-center gap-2">
          <input type="checkbox" checked={unattended} onChange={(e) => setUnattended(e.target.checked)} />
          przebieg bez Ciebie (claude -p)
        </label>
        <label className="flex items-center gap-2">
          <input type="checkbox" checked={rulesLoaded} onChange={(e) => setRulesLoaded(e.target.checked)} />
          .claude/settings.json z regułami i hookiem wczytany (w worktree tylko po commicie)
        </label>
        <label className="flex items-center gap-2">
          <input type="checkbox" checked={sandbox} onChange={(e) => setSandbox(e.target.checked)} />
          sandbox z scripts/nocna-wachta.json (tryb ścisły, strictAllowlist, sieć tylko do registry.npmjs.org)
        </label>
      </div>
      <ol className="flex flex-wrap gap-2 text-xs">
        {LAYERS.map((l) => (
          <li key={l} className={l === verdict.layer ? 'rounded bg-slate-100 px-2 py-1 font-bold text-slate-900' : 'rounded bg-slate-800 px-2 py-1 text-slate-400'}>
            {l}
          </li>
        ))}
      </ol>
      <p role="status" className="rounded border border-slate-700 p-2 text-sm">
        <strong className={RESULT_CLASS[verdict.result]}>{verdict.result}</strong>{' '}
        {verdict.text}
      </p>
    </div>
  );
}

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Reguły deny i hooki z .claude/settings.json nie są w commicie, a Ty uruchamiasz claude -p --worktree api-bledy. Co z nimi będzie w tym przebiegu?

  2. 2. Pracujesz w trybie auto, a projekt nie ma reguły deny dla .env. Co się stanie, gdy Claude zechce przeczytać .env?

To 2 z 5 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż regułę deny, która nie pozwoli Claude zresetować bazy deweloperskiej Prismy z żadną opcją:

  1. PytanieQuiz: Reguły przed startem w worktree
  2. PytanieQuiz: Klasyfikator a plik .env
  3. Ułóż w kolejnościSortowanie: Reguła deny dla resetu bazy
  4. PytanieQuiz: Blokada klasyfikatora w claude -p
  5. PytanieQuiz: Zasięg sandboxa
  6. PytanieQuiz: Gdzie działa blok autoMode

Przydatne artykuły