Kurs vibe coding z Claude Code · Moduł 15: Claude Code dla zaawansowanych
Claude Code bez rozmowy: tryb -p, potoki i sesje
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
-pjak 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.mdUważ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 mainTrzy 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 testKaż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:
- 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.
- Czy zarzut się potwierdza? Pierwszy tak:
z.url()z Zod przepuściło u nasjavascript: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. - Czego recenzent nie widział? Test "odrzuca obraz spoza /pins/" w
lib/pinInput.test.tspo tej zmianie pada, co pokażenpm 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 jsonPlik 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 2git 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. Którą flagą zostawisz Claude w przebiegu claude -p tylko narzędzie Read?
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):
Zadania po tej lekcji
- PytanieQuiz: Zestaw narzędzi w trybie -p
- PytanieQuiz: Zapis pliku bez zgody w -p
- Kliknij w kolejnościSekwencja: Token subskrypcji dla CI
- PytanieQuiz: Flaga --bare
- Kliknij w kolejnościSekwencja: Powrót do przebiegu po identyfikatorze
- Ułóż w kolejnościSortowanie: Diff gałęzi do pliku
- Ułóż w kolejnościSortowanie: Recenzja ze schematem JSON
- PytanieQuiz: ANTHROPIC_API_KEY w trybie -p
- PytanieQuiz: Cudzy projekt a tryb -p
- Kliknij w kolejnościSekwencja: Sprawdzenie logowania
- PytanieQuiz: Diff z poczekalni
- PytanieQuiz: Pusty diff
- Kliknij w kolejnościSekwencja: Zatwierdzony zapis w -p
- Zadanie z kodemPraktyka: Skrypt recenzji przed commitem
- PytanieQuiz: Kształt odpowiedzi
- PytanieQuiz: Model w skrypcie
- Kliknij w kolejnościSekwencja: Przebieg bez narzędzi
- PytanieQuiz: Powrót do przebiegu -p
- Ułóż w kolejnościSortowanie: Drugi projekt przez --add-dir