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

Claude Code bez rozmowy: tryb -p, potoki i sesje

10 min czytania
W tej lekcji13

Trzynaście klonów za Tobą i pewnie zauważyłeś, że część rozkazów wydajesz codziennie tymi samymi słowami. Przed commitem prosisz o przegląd zmian, po przerwie o streszczenie diffu, a gdy CI pada, wklejasz log i pytasz o przyczynę. Za każdym razem otwierasz sesję, przepisujesz to samo polecenie i czekasz. W ostatnim module zabierasz Claude Code tam, gdzie nikt go nie pilnuje: do skryptów, pętli i CI.

Co już umiesz

W lekcji 12_5 uruchomiłeś claude -p z flagami --allowedTools, --permission-mode dontAsk, --max-turns i --output-format json, a w lekcji 12_7 posadziłeś Claude w GitHub Actions. Z lekcji 4_10 znasz claude -c, claude -r i nazwane sesje, a z lekcji 2_9 komendę /code-review i czytanie diffu w Cursorze. W lekcji 1_5 poznałeś git add, a w lekcji 5_10 usłyszałeś, że Sonnet kosztuje mniej przy rutynie. Tego tu nie powtarzam: dokładam to, czego potrzebuje rozkaz wydawany bez rozmowy.

Czego się nauczysz

  • podawać Claude dane potokiem i zapisywać odpowiedź do pliku;
  • wybrać właściwy diff i nie wysłać pustego;
  • wymusić kształt odpowiedzi zdaniem albo schematem JSON;
  • zawęzić narzędzia, model i logowanie przebiegu;
  • wracać do przebiegów -p jak do zwykłych sesji.

Trzy znaki terminala: |, < i >

Strumień to tekst, który program przyjmuje na wejściu albo wypisuje na wyjściu. Pionowa kreska |, czyli potok, łączy wyjście jednej komendy z wejściem następnej, a claude -p czyta takie wejście razem z poleceniem:

git diff --cached | claude -p "Streść te zmiany w trzech punktach."

Claude dostaje diff gotowy na tacy, więc nie musi niczego szukać w projekcie. Żaden plik się nie zmienia, a komenda kończy się razem z odpowiedzią. Dwa pozostałe znaki przekierowują strumień: < wlewa plik na wejście, a > zapisuje wyjście do pliku.

claude -p "Wyjaśnij przyczynę pierwszego błędu z tego logu." < build.log > wyjasnienie.md

Uważaj na jedno: > czyści plik docelowy, zanim komenda w ogóle ruszy, więc nigdy nie kieruj wyjścia do pliku, który Claude ma przeczytać. Wejście z potoku ma limit 10 MB (stan na listopad 2026); większy plik wskaż w poleceniu ścieżką.

Który diff: trzy porcje zmian

Git trzyma zmiany w trzech miejscach, a każda komenda pokazuje inną porcję:

git diff               # zmiany jeszcze niedodane przez git add
git diff --cached      # poczekalnia (staging area): to, co trafi do commita
git diff main...HEAD   # commity gałęzi od miejsca, w którym odbiła od main

Trzy kropki każą liczyć od rozwidlenia, więc nie zobaczysz cudzych commitów, które w tym czasie trafiły na main. Żadna z tych komend niczego nie zapisuje. Pułapka czeka w pustym diffie: po git add zwykłe git diff nic nie wypisze, Claude dostanie samo polecenie i z pełnym przekonaniem opowie o niczym. Przed commitem recenzujesz więc --cached, przed pull requestem main...HEAD.

Polecenie dla Claude Code

W Treasure Map poprosiłeś Claude o dwie zmiany w lib/pinInput.ts: pin może mieć obraz spod pełnego adresu, a tagów może być dziesięć. Zrobiłeś git add lib/pinInput.ts i zanim podpiszesz commit, chcesz listy problemów, a nie wykładu.

Polecenie dla Claude Code (w terminalu Cursora):

git diff --cached | claude -p "Zrecenzuj te zmiany przed commitem: błędy i bezpieczeństwo.
Odpowiedz wyłącznie listą, jedna linia na problem:
plik:linia | problem | propozycja.
Bez wstępu i bez podsumowania. Gdy nic nie znajdziesz, napisz: Brak uwag." \
  --model sonnet --tools ""

Kształt odpowiedzi stoi w poleceniu, a dwie flagi robią z recenzji szybki odruch. --model sonnet bierze tańszy model do rutyny, a --tools "" odbiera Claude wszystkie narzędzia, więc widzi tylko diff i odpowiada w jednej turze.

Co napisał Claude

Na dysku nie powstało nic, w terminalu stoi lista. Oto skrót naszego przebiegu:

lib/pinInput.ts:9 | z.url() przyjmuje każdy schemat (javascript:, data:, http:) i każdy host | zawęź do https: i hostów z images.remotePatterns
lib/pinInput.ts:9 | startsWith("/pins/") przepuszcza /pins/../../coś | odrzucaj ścieżki z ..
lib/pinInput.ts:9 | wspólny komunikat unii zastąpił dokładne komunikaty | osobne komunikaty dla gałęzi
lib/pinInput.ts:13 | limit to 10, a komunikat mówi "Najwyżej 5 tagów." | ujednolić limit i komunikat
lib/pinInput.ts:13 | podwojenie limitu bez uzasadnienia | potwierdź zmianę i dopisz test

Każda linia ma plik, numer linii i propozycję, więc da się ją sprawdzić, a skrypt mógłby je nawet policzyć. Claude niczego nie poprawił: recenzja z potoku daje opinię, a nie zmianę.

Przegląd kapitana

Otwórz w Cursorze panel Source Control, rozwiń Staged Changes i kliknij lib/pinInput.ts. Porównaj każdą pozycję z diffem:

  1. Czy linia jest w diffie? Linie 9 i 13 są. Numer spoza diffu oznacza uwagę o starym kodzie albo zmyślenie, więc sprawdź go w pliku.
  2. Czy zarzut się potwierdza? Pierwszy tak: z.url() z Zod przepuściło u nas javascript:alert(1). Drugi dotyczy linii, której sens się nie zmienił; to osobne zadanie, nie ten commit. Piąty to przypuszczenie bez dowodu, więc go odrzucasz.
  3. Czego recenzent nie widział? Test "odrzuca obraz spoza /pins/" w lib/pinInput.test.ts po tej zmianie pada, co pokaże npm run test -- --run. Bez narzędzi Claude nie zajrzał do testów: szybka recenzja z potoku nie zastępuje testów ani /code-review.

Typowy błąd agenta to esej zamiast listy, gdy polecenie nie podaje kształtu odpowiedzi: akapity, nagłówki i pochwały, których nie porównasz z diffem. Rozpoznasz go po pierwszym zdaniu w rodzaju "Oto moja analiza", a leczy go jedna linia z wzorem odpowiedzi.

Zapis bez zgody: co robi -p

Co się stanie, gdy w trybie -p poprosisz o zapis pliku i nie dodasz żadnej flagi uprawnień? Dokumentacja mówi, że claude -p startuje dziś w trybie Manual i odrzuca każde wywołanie, które wymaga zgody. Sprawdziliśmy to na Treasure Map:

claude -p "Napisz testy Vitest dla @lib/plural.ts i zapisz je w lib/plural.test.ts." \
  --model sonnet --tools "Read,Write" --max-turns 3 --output-format json

Plik nie powstał. W JSON pole permission_denials wymieniło odrzucone narzędzie Write razem z całą treścią testów, a w result Claude napisał, że zapis zablokowały uprawnienia. Najważniejsze: komenda skończyła się kodem 0, czyli sukcesem. Skrypt, który patrzy tylko na kod wyjścia, uzna, że wszystko poszło dobrze, więc sprawdzaj plik albo permission_denials. Zapis zatwierdzasz flagą (--allowedTools "Write" albo --permission-mode acceptEdits) albo prosisz o samą treść i kierujesz ją > do pliku, co zobaczysz w następnej lekcji.

Trzy flagi narzędzi

Te trzy flagi brzmią podobnie, a robią co innego:

claude -p "..." --tools "Read"                         # zestaw narzędzi: tylko Read
claude -p "..." --allowedTools "Bash(npm run test *)"  # testy bez pytania, reszta po staremu
claude -p "..." --disallowedTools "Bash(git push *)"   # tej komendy nie wykona nigdy

--tools zawęża zestaw wbudowanych narzędzi, a "" odbiera wszystkie. --allowedTools niczego nie odbiera, tylko z góry zatwierdza wymienione wywołania. --disallowedTools z gołą nazwą narzędzia usuwa je z zasięgu Claude, a z wzorcem odrzuca tylko pasujące komendy. Polecam myśleć tak: najpierw --tools mówi, po jakie narzędzia Claude w ogóle może sięgnąć, potem --allowedTools mówi, co z tego robi bez pytania.

Kształt wymuszony schematem

Zdanie "odpowiedz listą" model zwykle szanuje, ale skrypt woli gwarancję. Flaga --json-schema przyjmuje schemat JSON, czyli opis pól, jakie ma mieć wynik. Zapisz go w scripts/review-schema.json:

{
  "type": "object",
  "properties": {
    "findings": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "file": { "type": "string" },
          "line": { "type": "integer" },
          "problem": { "type": "string" },
          "fix": { "type": "string" }
        },
        "required": ["file", "line", "problem", "fix"]
      }
    }
  },
  "required": ["findings"]
}

Schemat mówi: obiekt z tablicą findings, a w niej każdy problem z plikiem, numerem linii, opisem i poprawką. Ten plik niczego nie uruchamia, tylko opisuje kształt. Teraz przebieg, który go używa:

git diff --cached | claude -p "Zrecenzuj te zmiany przed commitem: błędy i bezpieczeństwo." \
  --model sonnet --tools "" --output-format json \
  --json-schema "$(cat scripts/review-schema.json)" | jq -c '.structured_output.findings[]'

Odpowiedź według schematu trafia do pola structured_output, a jq -c wypisuje każdy problem jako jedną linię JSON. U nas wyszły cztery problemy z tymi samymi liniami 9 i 13. Dokumentacja ostrzega, że gdy przebieg skończy się bez poprawnego wyniku, pola structured_output nie będzie, więc sprawdź je, zanim skrypt zaufa liczbie.

Model, logowanie i --bare

Bez --model skrypt bierze model domyślny z Twoich ustawień, czyli ostatni wybór z /model. Nasz pierwszy przebieg recenzji poszedł bez tej flagi i bez --tools "": najdroższy model z ustawień czytał pliki, wyczerpał --max-turns 3, skończył się błędem bez odpowiedzi i według szacunku kosztował ponad pięć razy więcej niż przebieg z --model sonnet.

Logowanie też działa w skrypcie inaczej. Gdy w środowisku stoi ANTHROPIC_API_KEY, tryb -p używa klucza zawsze, więc płacisz za tokeny mimo subskrypcji. claude auth status --text pokaże, czym się logujesz. Dla CI na subskrypcji claude setup-token wypisuje długotrwały token, który wkładasz do sekretu CLAUDE_CODE_OAUTH_TOKEN, jak w lekcji 12_7.

Flaga --bare pomija hooki, skille, subagentów, pluginy, serwery MCP, pamięć automatyczną i CLAUDE.md, więc przebieg robi to samo na każdej maszynie. Nie czyta jednak Twojego logowania ani CLAUDE_CODE_OAUTH_TOKEN: potrzebuje ANTHROPIC_API_KEY albo apiKeyHelper, czyli płatności za tokeny. To flaga dla CI z kluczem API, nie dla laptopa na subskrypcji. Druga strona medalu: bez --bare przebieg -p w cudzym repozytorium uruchomi hooki z jego .claude/settings.json i połączy serwery z .mcp.json bez żadnego pytania. Przeczytaj folder .claude/ obcego projektu, zanim puścisz na nim skrypt.

Sesje, do których wracasz

Przebieg -p też jest sesją. claude -p "..." --continue dopisuje kolejne polecenie do ostatniej rozmowy w folderze, choćby "teraz zaproponuj poprawkę do linii 13". Zwykłe claude -c pomija jednak sesje z -p, więc do konkretnego przebiegu wracasz po identyfikatorze:

ID=$(git diff --cached | claude -p "Zrecenzuj te zmiany." --model sonnet --output-format json | jq -r '.session_id')
claude -p "Zaproponuj poprawkę do linii 13." --resume "$ID"

Pierwsza linia zapisuje identyfikator sesji z pola session_id, druga dopisuje nowe polecenie do tej samej rozmowy, z całą recenzją w historii, choćby z innego folderu. Gdy chcesz pokazać Claude drugi projekt, na przykład testy z klonu Spotify, dodaj --add-dir ../sea-shanty-sounds na końcu komendy, po poleceniu: flaga przyjmuje kilka katalogów i wszystko za nią uzna za ścieżki.

Następny krok

Zamknij recenzję w skrypcie, żeby nie przepisywać jej codziennie. W sesji Claude Code napisz:

Zapisz recenzję z potoku jako scripts/code-review.sh. Gdy poczekalnia jest pusta,
skrypt ma wypisać podpowiedź i skończyć bez wołania Claude.
Będzie gotowe, gdy: skrypt ma to sprawdzenie i tę samą komendę claude -p co wyżej.
Nie uruchamiaj go, zrobię to sam w terminalu.

W Cursorze otwórz scripts/code-review.sh i przeczytaj, co powstało:

#!/bin/bash
# code-review.sh: recenzja zmian z poczekalni, zanim zrobisz commit

if git diff --cached --quiet; then
  echo "Poczekalnia jest pusta. Najpierw: git add <pliki>"
  exit 1
fi

git diff --cached | claude -p "Zrecenzuj te zmiany przed commitem: błędy i bezpieczeństwo.
Odpowiedz wyłącznie listą, jedna linia na problem:
plik:linia | problem | propozycja.
Bez wstępu i bez podsumowania. Gdy nic nie znajdziesz, napisz: Brak uwag." \
  --model sonnet --tools "" --max-turns 2

git diff --cached --quiet niczego nie wypisuje, tylko kończy się sukcesem, gdy poczekalnia jest pusta, więc if zatrzymuje skrypt, zanim zapłacisz za recenzję niczego. --max-turns 2 to hamulec na wypadek, gdyby przebieg się przeciągnął. Potem poproś Claude o poprawki z listy, uruchom npm run test -- --run i bash scripts/code-review.sh, a commit podpisz, gdy recenzent odpowie "Brak uwag" albo uwagi, które zostały, świadomie odrzucisz.

W edytorze obok złożysz komendę z potoku i flag, a symulator pokaże, co dociera do Claude, czego mu wolno i kto płaci za przebieg.

Zapamiętaj: rozmowa jest na mostku, a -p to wachta, która pracuje, gdy śpisz, pod warunkiem, że zostawiłeś jej jasny rozkaz.

Kod do tej lekcji: App.tsx
// Symulator wachty: co dociera do Claude w trybie -p, czego mu wolno i kto płaci
import { useState } from 'react';

type Source = 'cached' | 'worktree' | 'branch';
type Task = 'review' | 'write';
type Tools = 'default' | 'read' | 'none';
type Mode = 'manual' | 'acceptEdits' | 'dontAsk';
type Auth = 'subscription' | 'apiKey' | 'oauthToken';
type Output = 'text' | 'json' | 'schema';

export interface Config {
  task: Task;
  source: Source;
  staged: boolean;
  tools: Tools;
  mode: Mode;
  allowWrite: boolean;
  sonnet: boolean;
  bare: boolean;
  auth: Auth;
  output: Output;
}

export interface Verdict {
  ok: boolean;
  text: string;
}

const PIN_DIFF = [
  '--- a/lib/pinInput.ts',
  '+++ b/lib/pinInput.ts',
  '-    src: z.string().startsWith("/pins/", "Obraz musi leżeć w /pins/."),',
  '+    src: z.union([z.string().startsWith("/pins/"), z.url()], "Obraz z /pins/ albo pełny adres."),',
];

const BRANCH_DIFF = [
  'commit 1: feat(pins): zapisywanie pinów na tablicach',
  'commit 2: test(boards): testy canSavePins',
  '(tylko zapisane commity; zmiany sprzed git commit tu nie trafiają)',
];

const SOURCE_CMD: Record<Source, string> = {
  cached: 'git diff --cached',
  worktree: 'git diff',
  branch: 'git diff main...HEAD',
};

const PROMPT: Record<Task, string> = {
  review: '"Zrecenzuj te zmiany. Odpowiedz listą: plik:linia | problem | propozycja."',
  write: '"Napisz testy Vitest dla @lib/plural.ts i zapisz je w lib/plural.test.ts."',
};

export function stdinFor(source: Source, staged: boolean): string[] {
  if (source === 'cached') return staged ? PIN_DIFF : [];
  if (source === 'worktree') return staged ? [] : PIN_DIFF;
  return BRANCH_DIFF;
}

export function buildCommand(c: Config): string {
  const parts: string[] = [];
  if (c.task === 'review') parts.push(SOURCE_CMD[c.source], '|');
  parts.push('claude');
  if (c.bare) parts.push('--bare');
  parts.push('-p', PROMPT[c.task]);
  if (c.sonnet) parts.push('--model sonnet');
  if (c.tools === 'read') parts.push('--tools "Read"');
  if (c.tools === 'none') parts.push('--tools ""');
  if (c.mode !== 'manual') parts.push('--permission-mode ' + c.mode);
  if (c.allowWrite) parts.push('--allowedTools "Write"');
  if (c.output !== 'text') parts.push('--output-format json');
  if (c.output === 'schema') parts.push('--json-schema "$(cat scripts/review-schema.json)"');
  if (c.output === 'json') parts.push("| jq -r '.result'");
  if (c.output === 'schema') parts.push("| jq -c '.structured_output.findings[]'");
  return parts.join(' ');
}

export function inputVerdict(c: Config): Verdict {
  if (c.task === 'write') return { ok: true, text: 'Bez potoku: Claude dostaje samo polecenie i sam sięga po plik.' };
  const lines = stdinFor(c.source, c.staged);
  if (lines.length === 0) {
    return { ok: false, text: 'Pusty diff: Claude dostaje samo polecenie i z przekonaniem opowie o niczym.' };
  }
  return { ok: true, text: 'Claude dostaje polecenie i ' + lines.length + ' linie z wejścia.' };
}

export function toolsVerdict(c: Config): Verdict {
  const write = c.task === 'write';
  if (c.tools === 'none') {
    return { ok: !write, text: 'Zero narzędzi: Claude widzi tylko polecenie i wejście, odpowiada w jednej turze.' + (write ? ' Pliku nie zapisze.' : '') };
  }
  if (c.tools === 'read') {
    return { ok: !write, text: 'Tylko Read: Claude czyta pliki projektu.' + (write ? ' Narzędzia Write nie ma w zestawie, więc pliku nie zapisze.' : '') };
  }
  if (!write) return { ok: true, text: 'Pełny zestaw narzędzi: Claude może czytać projekt i uruchamiać komendy tylko do odczytu.' };
  if (c.allowWrite) return { ok: true, text: 'Write zatwierdzony przez --allowedTools: lib/plural.test.ts powstaje bez pytania.' };
  if (c.mode === 'acceptEdits') {
    return { ok: true, text: 'acceptEdits: Claude zapisuje pliki w projekcie bez pytania. Uruchamiaj tylko na czystym drzewie Gita.' };
  }
  return { ok: false, text: 'Zapis odrzucony: Write trafia do permission_denials, pliku nie ma, a kod wyjścia to 0.' };
}

export function authVerdict(bare: boolean, auth: Auth): Verdict {
  if (bare) {
    if (auth === 'apiKey') return { ok: true, text: '--bare z kluczem API: płacisz za tokeny, a hooki, skille, MCP i CLAUDE.md zostają w porcie.' };
    return { ok: false, text: '--bare nie czyta logowania ani CLAUDE_CODE_OAUTH_TOKEN: bez ANTHROPIC_API_KEY przebieg skończy się błędem.' };
  }
  if (auth === 'apiKey') return { ok: true, text: 'ANTHROPIC_API_KEY w trybie -p działa zawsze: płacisz za tokeny mimo subskrypcji.' };
  if (auth === 'oauthToken') return { ok: true, text: 'Token z claude setup-token: przebieg zużywa limit subskrypcji.' };
  return { ok: true, text: 'Logowanie z /login: limit subskrypcji. Bez --bare ruszą też hooki i .mcp.json projektu.' };
}

export function outputVerdict(c: Config): Verdict {
  const model = c.sonnet ? 'Tańszy Sonnet do rutyny. ' : 'Model z Twoich ustawień, czyli ostatni wybór z /model. ';
  if (c.output === 'text') return { ok: true, text: model + 'Zwykły tekst: dobry dla oka, kruchy dla skryptu.' };
  if (c.output === 'json') return { ok: true, text: model + 'Odpowiedź w polu result, obok koszt i permission_denials.' };
  return { ok: true, text: model + 'Wynik według schematu w polu structured_output. Sprawdź, czy pole istnieje.' };
}

const START: Config = {
  task: 'review',
  source: 'cached',
  staged: true,
  tools: 'none',
  mode: 'manual',
  allowWrite: false,
  sonnet: true,
  bare: false,
  auth: 'subscription',
  output: 'text',
};

function Choice<T extends string>(props: { label: string; value: T; options: [T, string][]; onChange: (v: T) => void }) {
  return (
    <label className="flex flex-col gap-1 text-sm">
      <span className="font-semibold">{props.label}</span>
      <select
        className="rounded border border-slate-600 bg-slate-900 p-1"
        value={props.value}
        onChange={(e) => props.onChange(e.target.value as T)}
      >
        {props.options.map(([v, text]) => (
          <option key={v} value={v}>{text}</option>
        ))}
      </select>
    </label>
  );
}

function Row({ title, verdict }: { title: string; verdict: Verdict }) {
  return (
    <li className="rounded border border-slate-700 p-2">
      <strong className={verdict.ok ? 'text-emerald-400' : 'text-amber-400'}>{title}</strong>
      <p className="text-sm">{verdict.text}</p>
    </li>
  );
}

export default function App() {
  const [c, setC] = useState<Config>(START);
  const set = <K extends keyof Config>(key: K, value: Config[K]) => setC({ ...c, [key]: value });
  const stdin = c.task === 'review' ? stdinFor(c.source, c.staged) : [];

  return (
    <div className="min-h-screen space-y-4 bg-slate-950 p-4 text-slate-100">
      <h1 className="text-xl font-bold">Wachta bez rozmowy: claude -p w Treasure Map</h1>
      <div className="grid gap-3 md:grid-cols-3">
        <Choice label="Zadanie" value={c.task} onChange={(v) => set('task', v)} options={[['review', 'Recenzja diffu'], ['write', 'Zapis pliku testów']]} />
        <Choice label="Źródło potoku" value={c.source} onChange={(v) => set('source', v)} options={[['cached', 'git diff --cached'], ['worktree', 'git diff'], ['branch', 'git diff main...HEAD']]} />
        <Choice label="Narzędzia (--tools)" value={c.tools} onChange={(v) => set('tools', v)} options={[['default', 'domyślne'], ['read', '"Read"'], ['none', '""']]} />
        <Choice label="Tryb uprawnień" value={c.mode} onChange={(v) => set('mode', v)} options={[['manual', 'Manual (domyślny w -p)'], ['acceptEdits', 'acceptEdits'], ['dontAsk', 'dontAsk']]} />
        <Choice label="Logowanie" value={c.auth} onChange={(v) => set('auth', v)} options={[['subscription', 'subskrypcja (/login)'], ['apiKey', 'ANTHROPIC_API_KEY'], ['oauthToken', 'CLAUDE_CODE_OAUTH_TOKEN']]} />
        <Choice label="Wynik" value={c.output} onChange={(v) => set('output', v)} options={[['text', 'tekst'], ['json', 'JSON i jq'], ['schema', '--json-schema i jq']]} />
      </div>
      <div className="flex flex-wrap gap-4 text-sm">
        <label className="flex items-center gap-2"><input type="checkbox" checked={c.staged} onChange={(e) => set('staged', e.target.checked)} />zrobiłem git add</label>
        <label className="flex items-center gap-2"><input type="checkbox" checked={c.allowWrite} onChange={(e) => set('allowWrite', e.target.checked)} />--allowedTools "Write"</label>
        <label className="flex items-center gap-2"><input type="checkbox" checked={c.sonnet} onChange={(e) => set('sonnet', e.target.checked)} />--model sonnet</label>
        <label className="flex items-center gap-2"><input type="checkbox" checked={c.bare} onChange={(e) => set('bare', e.target.checked)} />--bare</label>
      </div>
      <pre className="overflow-x-auto whitespace-pre-wrap rounded bg-slate-900 p-2 font-mono text-xs">{buildCommand(c)}</pre>
      <section>
        <h2 className="font-semibold">Co płynie na wejście</h2>
        <pre className="rounded bg-slate-900 p-2 font-mono text-xs">{stdin.length ? stdin.join('\n') : '(nic)'}</pre>
      </section>
      <ul className="space-y-2">
        <Row title="Wejście" verdict={inputVerdict(c)} />
        <Row title="Narzędzia i zapis" verdict={toolsVerdict(c)} />
        <Row title="Logowanie i rachunek" verdict={authVerdict(c.bare, c.auth)} />
        <Row title="Model i wynik" verdict={outputVerdict(c)} />
      </ul>
    </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. Którą flagą zostawisz Claude w przebiegu claude -p tylko narzędzie Read?

  2. 2. Skrypt uruchamia claude -p "Napisz testy Vitest dla @lib/plural.ts i zapisz je w lib/plural.test.ts." bez żadnej flagi uprawnień. Co się stanie?

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

Zadania praktyczne w grze

  • Klikanie w kolejności

    Kliknij elementy w kolejności, aby zbudować komendę, która tworzy długotrwały token subskrypcji do CI:

  • Klikanie w kolejności

    Kliknij elementy w kolejności, aby dopisać nowe polecenie do przebiegu, którego identyfikator zapisałeś w zmiennej ID:

  • Układanie w poziomie

    Ułóż polecenie, które przekazuje zmiany całej gałęzi do Claude i zapisuje odpowiedź do pliku:

  • Układanie w poziomie

    Ułóż polecenie, które wymusza kształt recenzji schematem i wypisuje każdy problem w osobnej linii:

  • Klikanie w kolejności

    Kliknij elementy w kolejności, aby zbudować komendę, która pokazuje czytelnym tekstem, czym logują się Twoje przebiegi:

  • Klikanie w kolejności

    Kliknij elementy w kolejności, aby zbudować przebieg, w którym zapis pliku jest z góry zatwierdzony:

  • Edytor kodu

    W pliku commands.sh napisz skrypt code-review.sh: pobierz zmiany ze staging area (git diff --cached), przekaż je potokiem do claude -p i poproś o wskazanie błędów oraz problemów z bezpieczeństwem.

  • Klikanie w kolejności

    Kliknij elementy w kolejności, aby zbudować przebieg, w którym Claude widzi tylko polecenie i wejście z potoku:

  • Układanie w poziomie

    Ułóż polecenie, które daje Claude wgląd w drugi projekt (pamiętaj, że --add-dir przyjmuje kilka katalogów):

  1. PytanieQuiz: Zestaw narzędzi w trybie -p
  2. PytanieQuiz: Zapis pliku bez zgody w -p
  3. Kliknij w kolejnościSekwencja: Token subskrypcji dla CI
  4. PytanieQuiz: Flaga --bare
  5. Kliknij w kolejnościSekwencja: Powrót do przebiegu po identyfikatorze
  6. Ułóż w kolejnościSortowanie: Diff gałęzi do pliku
  7. Ułóż w kolejnościSortowanie: Recenzja ze schematem JSON
  8. PytanieQuiz: ANTHROPIC_API_KEY w trybie -p
  9. PytanieQuiz: Cudzy projekt a tryb -p
  10. Kliknij w kolejnościSekwencja: Sprawdzenie logowania
  11. PytanieQuiz: Diff z poczekalni
  12. PytanieQuiz: Pusty diff
  13. Kliknij w kolejnościSekwencja: Zatwierdzony zapis w -p
  14. Zadanie z kodemPraktyka: Skrypt recenzji przed commitem
  15. PytanieQuiz: Kształt odpowiedzi
  16. PytanieQuiz: Model w skrypcie
  17. Kliknij w kolejnościSekwencja: Przebieg bez narzędzi
  18. PytanieQuiz: Powrót do przebiegu -p
  19. Ułóż w kolejnościSortowanie: Drugi projekt przez --add-dir

Przydatne artykuły