Kurs vibe coding z Claude Code · Moduł 15: Claude Code dla zaawansowanych
Koszty, limity i wybór modelu
W tej lekcji9
Połowa projektu końcowego. Od rana pracowały dwie szalupy z lekcji 14_9, w nocy wachta z lekcji 14_7, a pętla co dziesięć minut pytała o commity. W środku polecenia Claude staje, a na dole terminala pojawiają się dwie linie:
Usage limit reached · limit resets 3:45pm
Continuing automatically at 3:45pm · Esc to cancelLimit planu skończył się w najgorszym momencie. Ta lekcja uczy dwóch rzeczy: co zrobić, gdy już stoisz, i jak ustawić rejs tak, żeby proch nie kończył się na rutynie.
Co już umiesz
W lekcji 5_10 poznałeś /usage z rozbiciem na skille, subagentów, pluginy i serwery MCP, poziomy effort, słowo ultrathink i zasadę, że subagent daje równoległość, a nie mądrzejszą odpowiedź. W lekcji 4_10 zajrzałeś do ładowni przez /context. Z lekcji 14_1 wiesz, że claude -p bez --model bierze model z Twoich ustawień, a klucz z ANTHROPIC_API_KEY ma w nim pierwszeństwo przed subskrypcją. W lekcji 14_4 usłyszałeś, że każdy włączony plugin wnosi opisy do każdej tury, w lekcji 14_7 postawiłeś --max-turns, a w lekcji 14_9 policzyłeś, że równoległe sesje płacą z jednego limitu. Tu składasz z tego budżet rejsu.
Gdy limit stanie w połowie
Te dwie linie to automatyczne wznowienie. W sesji interaktywnej na subskrypcji Claude Code czeka w otwartej sesji i po odnowieniu limitu sam podejmuje przerwane zadanie, bez ponownego wysyłania Twojej wiadomości. Sesję zostawiasz więc otwartą, a Esc anuluje czekanie. Po kilku wznowieniach z rzędu Claude Code przestaje czekać sam i odsyła Cię do /rate-limit-options: tam wybierasz czekanie, dokupienie dodatkowych środków (usage credits) przez /usage-credits albo wyższy plan. Wznowione zadanie nadal pyta o zgody, więc może stanąć na pytaniu, gdy Ciebie nie ma. Czekanie ratuje jedno zadanie, ale nie mówi, dlaczego limit poszedł tak szybko.
Gdzie poszły tokeny
Zacznij od /usage i klawisza w, czyli ostatnich siedmiu dni. Poza rozbiciem z lekcji 5_10 jest tam część Loops: najcięższe pętle /loop z ostatnich dni, z liczbą uruchomień i tokenami na jedno uruchomienie. Pętla z lekcji 14_9, która co dziesięć minut wysyłała całą rozmowę, wypłynie właśnie tam.
Druga sprawa to ładunek, który płynie z każdą turą, choć nikt go nie zamawiał. Do każdej tury trafia CLAUDE.md z importami, opisy skilli i subagentów oraz nazwy narzędzi z serwerów MCP. Pełne definicje narzędzi MCP ładują się dopiero przy użyciu, a pełna treść skilla dopiero po jego wywołaniu. Wyjątkiem jest skill z disable-model-invocation: true, taki jak /przed-commitem z lekcji 14_4: jego opisu nie ma w kontekście wcale. Komenda /skill-doctor pokazuje, ile kosztuje każdy skill i których nigdy nie użyłeś. Resztę zbadasz poleceniem:
Polecenie dla Claude Code:
Nie zmieniaj plików. Wypisz, co w tym projekcie trafia do każdej tury: CLAUDE.md
z importami, opisy skilli i subagentów z .claude/ oraz serwery z .mcp.json. Przy
każdej pozycji podaj liczbę słów (wc -w) i powiedz, czy da się ją skrócić, przenieść
do skilla albo wyłączyć.Claude tylko czyta i liczy, a decyzję o wyłączeniu podejmujesz Ty. Długą procedurę z CLAUDE.md dokumentacja radzi przenieść do skilla, bo skill płaci za treść dopiero wtedy, gdy jest potrzebny.
Trzecie źródło to raport skryptu. Przebieg claude -p z --output-format json ma pole total_cost_usd i rozbicie na modele w modelUsage:
jq '{subtype, num_turns, total_cost_usd, modele: (.modelUsage | map_values(.costUSD))}' raport.jsonKwoty to szacunek Claude Code według cen katalogowych, a nie faktura. Na subskrypcji nic za nie nie płacisz, ale świetnie nadają się do porównań: ten sam przebieg na dwóch modelach, z subagentem i bez. U nas przebieg z pytaniem na jedno zdanie na Haiku miał dwie tury, a każde z jego zapytań niosło około 50 tysięcy tokenów: instrukcje, narzędzia, opisy skilli i pliki pamięci. Większość szła z pamięci podręcznej, ale każda nowa sesja startuje z tym samym ładunkiem, a u Ciebie jego wielkość zależy od skilli, pluginów i serwerów.
Hamulce dla skryptów
--max-turns z lekcji 14_7 liczy kroki agenta. --max-budget-usd liczy pieniądze: działa tylko w trybie -p, zatrzymuje przebieg, gdy szacunek wydatków dojdzie do podanej kwoty, i wlicza w to subagentów. Skrypt generate-tests.sh z lekcji 14_2 dostaje go w jednym miejscu:
claude -p "Napisz testy Vitest dla @$FILE: każda eksportowana funkcja i przypadki brzegowe.
Zwróć sam kod TypeScript, bez płotków Markdown i bez wyjaśnień." \
--model sonnet --max-turns 5 --max-budget-usd 0.5 > "$TEST_FILE.tmp" || continueKwota 0.5 to przykład, swoją wyliczysz za chwilę. U nas przebieg zatrzymany limitem skończył się kodem wyjścia 1, a w JSON-ie miał subtype równe error_max_budget_usd, pusty result i błąd Reached maximum budget. W skrypcie || continue przechodzi wtedy do następnego pliku i zostaje tylko .tmp.
Limit nie jest jednak ścianą. Claude Code porównuje wydatek z limitem po odpowiedzi modelu, a odpowiedź, która go przekroczy, i tak się liczy. U nas przebieg z celowo za małym limitem zatrzymał się dopiero po czterech turach, a total_cost_usd pokazał wielokrotność limitu. Limit działa też na jeden przebieg, więc pętla po dziesięciu plikach może wydać dziesięć razy tyle. Kwotę ustalasz więc z próby: jeden plik z --output-format json, odczyt total_cost_usd i num_turns, a do skryptu limit z zapasem.
Model i effort bez nadzoru
Rutyna i trudny problem potrzebują innych ustawień. Zmiana nazwy getCurrentUserId na getViewerId w około dziesięciu plikach Treasure Map to rutyna, którą sprawdzi tsc, a dokumentacja podaje taką zmianę jako przykład na low. Sesję otwierasz z flagami, które nie zapisują się jako domyślne:
claude --model sonnet --effort lowW tej sesji polecenie brzmi: "Zmień nazwę getCurrentUserId na getViewerId w lib/session.ts i we wszystkich użyciach, także w mockach testów. Gotowe, gdy npx tsc --noEmit i npm run test -- --run przechodzą". Do skryptów, które wieczorem przerabiają kilkanaście plików według wzoru, wystarcza Sonnet, a prostym subagentom Haiku, jak w lekcji 5_10.
Wyżej idziesz przy błędzie w cudzym kodzie, zmianie schematu albo szukaniu luki przed publikacją: model domyślny (stan na listopad 2026 to Opus) z high lub xhigh, a max tylko na naprawdę trudny problem, nad którym Claude pracuje bez Ciebie. Alias opusplan łączy oba światy: Opus planuje w trybie planowania, a Sonnet wykonuje. Fable wybierasz ręcznie przez /model fable i zależnie od planu bywa rozliczany z usage credits. W API Fable kosztuje za token cztery razy więcej niż Sonnet (stan na listopad 2026). W trybie -p nikt nie zobaczy pytania o zgodę, więc Claude Code rozlicza go z usage credits bez pytania. --model fable w pętli to decyzja finansowa, a nie techniczna.
Subskrypcja czy klucz API
Tryb -p używa klucza zawsze, gdy zmienna jest ustawiona. Sesja interaktywna pyta o niego raz i zapamiętuje odpowiedź. Po zatwierdzeniu płacisz za każdy token z konta API, choć plan masz opłacony. Wybór zmienisz przełącznikiem "Use custom API key" w /config, widocznym tylko wtedy, gdy zmienna jest ustawiona, a /status pokaże, które logowanie działa. Klucz ma sens w CI z --bare albo przy rozliczeniu zespołu. Zadania z /schedule i sesje w chmurze zawsze korzystają z subskrypcji.
Co podnosi koszt, a nie poprawia odpowiedzi
- subagent wysłany "po mądrzejszą odpowiedź": to ten sam model albo mniejszy, na tym samym zadaniu;
maxalbo Fable na rutynie, którą i tak sprawdzitsc;- zapomniana pętla
/loopw długiej rozmowie; - skille, pluginy i serwery MCP, których nie używasz, a które płyną z każdą turą;
/compactw ogromnej sesji, gdy historia nie jest Ci potrzebna:/clearnic nie kosztuje.
Przegląd kapitana
- Każdy
claude -pw skryptach ma--model,--max-turnsi--max-budget-usd. - Bez flagowców na rutynie. W skryptach nie ma
--model fableani--effort max. - Logowanie.
claude auth status --textpokazuje subskrypcję, gdy na nią liczysz, aenv | grep ANTHROPIC_API_KEYnic nie wypisuje. - Pętle. Część Loops w
/usagenie pokazuje pętli, o której zapomniałeś.
Typowy błąd agenta: prosisz o zmianę nazwy, a Claude proponuje /model fable i /effort max "żeby nic nie umknęło" albo wpisuje te flagi do skryptu. Rozpoznasz to po nazwie modelu i poziomie w komendzie. Zmianę nazwy sprawdza tsc, a nie głębsze myślenie, więc płacisz więcej za tę samą odpowiedź.
Następny krok
Zrób próbę na jednym pliku i poproś: "Dopisz w scripts/generate-tests.sh flagę --max-budget-usd z kwotą z próbnego przebiegu razy dwa, a w komentarzu nad pętlą zapisz, skąd ta liczba. Nie uruchamiaj pętli". Potem commit, na przykład "Hamulce kosztów w skryptach". W edytorze obok wpiszesz liczby ze swojej próby, a kalkulator pokaże, ile zapłaci cała pętla i czy limit nie jest za ciasny.
Pamiętaj: proch liczysz przed bitwą, a na rutynową wachtę nie wysyłasz okrętu flagowego.
Kod do tej lekcji: App.tsx
// Kalkulator pętli z hamulcami: ile zapłaci skrypt z claude -p, liczony z Twojego próbnego przebiegu
import { useState } from 'react';
export type Level = 'ok' | 'warn' | 'error';
export type Model = 'haiku' | 'sonnet' | 'opus' | 'fable';
export type Effort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
export type Kind = 'rutyna' | 'trudny';
export interface Finding {
level: Level;
text: string;
}
export interface Plan {
files: number;
testTurns: number;
testCost: string;
maxTurns: number;
budget: string;
model: Model;
effort: Effort;
kind: Kind;
smarterSubagent: boolean;
}
export interface Estimate {
expectedRuns: number;
worstRuns: number;
expectedUsd: number | null;
worstUsd: number | null;
suggestedBudget: number | null;
}
export function num(text: string): number | null {
const t = text.trim().replace(',', '.');
if (t === '') return null;
const n = Number(t);
return Number.isFinite(n) && n > 0 ? n : null;
}
// Jednostka: koszt Twojego próbnego przebiegu na jednym pliku. Koszt tury przybliżamy średnią z próby.
export function estimate(p: Plan): Estimate {
const files = Math.max(0, Math.floor(p.files));
const turns = Math.max(1, p.testTurns);
const cost = num(p.testCost);
const budget = num(p.budget);
const perRunWorst = Math.max(1, p.maxTurns) / turns;
let worstPerRun = perRunWorst;
if (cost !== null && budget !== null) {
const capRuns = budget / cost + 1 / turns;
worstPerRun = Math.min(perRunWorst, capRuns);
}
return {
expectedRuns: files,
worstRuns: files * worstPerRun,
expectedUsd: cost === null ? null : files * cost,
worstUsd: cost === null ? null : files * worstPerRun * cost,
suggestedBudget: cost === null ? null : Math.ceil(cost * 2 * 100) / 100,
};
}
export function review(p: Plan): Finding[] {
const out: Finding[] = [];
const cost = num(p.testCost);
const budget = num(p.budget);
if (p.maxTurns < p.testTurns) {
out.push({ level: 'error', text: '--max-turns ' + p.maxTurns + ' to mniej niż ' + p.testTurns + ' tur w próbie: przebiegi skończą się error_max_turns.' });
}
if (budget === null) {
out.push({ level: 'warn', text: 'Bez --max-budget-usd hamulcem jest tylko --max-turns.' });
} else if (cost === null) {
out.push({ level: 'warn', text: 'Wpisz total_cost_usd z próby, żeby ocenić limit.' });
} else if (budget < cost) {
out.push({ level: 'error', text: 'Limit niższy niż koszt próby: większość przebiegów zatrzyma error_max_budget_usd i zostawi tylko .tmp.' });
} else if (budget < cost * 1.5) {
out.push({ level: 'warn', text: 'Mały zapas. Plik trudniejszy niż próbny dojdzie do limitu, a odpowiedź, która go przekroczy, i tak się liczy.' });
} else {
out.push({ level: 'ok', text: 'Limit z zapasem: zatrzyma przebieg, który się zapętli, a zwykłym nie przeszkodzi.' });
}
if (p.model === 'fable') {
out.push({ level: 'error', text: 'Fable w -p: zależnie od planu idzie z usage credits, a nikt nie zobaczy pytania o zgodę.' });
}
if (p.kind === 'rutyna') {
if (p.effort === 'max') out.push({ level: 'error', text: 'max na rutynie przemyśliwa: płacisz więcej za odpowiedź nie lepszą niż z high.' });
else if (p.effort === 'xhigh' || p.effort === 'high') out.push({ level: 'warn', text: 'Rutynę i tak sprawdzi tsc albo testy. Wystarczy domyślne medium, a przy zmianie nazwy low.' });
if (p.model === 'opus') out.push({ level: 'warn', text: 'Do rutynowych przebiegów wystarcza Sonnet.' });
} else {
if (p.effort === 'low') out.push({ level: 'warn', text: 'Trudny problem na low: Claude szybciej da punkt wyjścia, ale mniej sprawdzi. Rozważ high albo xhigh.' });
if (p.model === 'haiku') out.push({ level: 'warn', text: 'Haiku to model do prostych zadań subagentów, nie do trudnego problemu.' });
}
if (p.smarterSubagent) {
out.push({ level: 'error', text: 'Subagent po mądrzejszą odpowiedź to ten sam model albo mniejszy na tym samym zadaniu: więcej tokenów, ta sama jakość.' });
}
return out;
}
export function command(p: Plan): string {
const parts = ['claude -p "Napisz testy Vitest dla @$FILE."', '--model ' + p.model];
if (p.effort !== 'medium') parts.push('--effort ' + p.effort);
parts.push('--max-turns ' + p.maxTurns);
const budget = num(p.budget);
if (budget !== null) parts.push('--max-budget-usd ' + budget);
parts.push('> "$TEST_FILE.tmp" || continue');
return parts.join(' ');
}
export function fmt(n: number): string {
return n.toFixed(2);
}
const START: Plan = {
files: 9,
testTurns: 4,
testCost: '',
maxTurns: 5,
budget: '',
model: 'sonnet',
effort: 'medium',
kind: 'rutyna',
smarterSubagent: false,
};
export const AGENT_MISTAKE: Plan = { ...START, model: 'fable', effort: 'max', maxTurns: 30 };
const LEVEL_CLASS: Record<Level, string> = {
ok: 'text-emerald-400',
warn: 'text-amber-400',
error: 'text-rose-400',
};
function Field(props: { label: string; value: string | number; onChange: (v: string) => void; hint?: string }) {
return (
<label className="flex flex-col gap-1 text-sm">
<span className="font-semibold">{props.label}</span>
<input className="rounded bg-slate-900 p-1 font-mono" value={props.value} onChange={(e) => props.onChange(e.target.value)} />
{props.hint ? <span className="text-xs text-slate-400">{props.hint}</span> : null}
</label>
);
}
export default function App() {
const [p, setP] = useState<Plan>(START);
const set = <K extends keyof Plan>(key: K, value: Plan[K]) => setP({ ...p, [key]: value });
const e = estimate(p);
const findings = review(p);
return (
<div className="min-h-screen space-y-4 bg-slate-950 p-4 text-slate-100">
<h1 className="text-xl font-bold">Ile zapłaci pętla?</h1>
<p className="text-sm text-slate-300">Liczby z próby wpisujesz sam: jeden plik, ten sam model, --output-format json, potem jq.</p>
<div className="flex flex-wrap gap-2 text-sm">
<button type="button" className="rounded bg-slate-800 px-2 py-1 hover:bg-slate-700" onClick={() => setP(START)}>Rutyna z lekcji</button>
<button type="button" className="rounded bg-slate-800 px-2 py-1 hover:bg-slate-700" onClick={() => setP(AGENT_MISTAKE)}>Błąd agenta: flagowiec na rutynie</button>
</div>
<div className="grid gap-3 md:grid-cols-3">
<Field label="Plików w pętli" value={p.files} onChange={(v) => set('files', Number(v) || 0)} />
<Field label="num_turns z próby" value={p.testTurns} onChange={(v) => set('testTurns', Number(v) || 1)} />
<Field label="total_cost_usd z próby" value={p.testCost} onChange={(v) => set('testCost', v)} hint="Twój szacunek z raportu, puste = liczymy w próbach" />
<Field label="--max-turns" value={p.maxTurns} onChange={(v) => set('maxTurns', Number(v) || 1)} />
<Field label="--max-budget-usd" value={p.budget} onChange={(v) => set('budget', v)} hint="puste = bez limitu" />
<label className="flex flex-col gap-1 text-sm">
<span className="font-semibold">Zadanie</span>
<select className="rounded bg-slate-900 p-1" value={p.kind} onChange={(ev) => set('kind', ev.target.value as Kind)}>
<option value="rutyna">rutyna (zmiana nazwy, testy według wzoru)</option>
<option value="trudny">trudny problem (cudzy błąd, luka)</option>
</select>
</label>
<label className="flex flex-col gap-1 text-sm">
<span className="font-semibold">--model</span>
<select className="rounded bg-slate-900 p-1 font-mono" value={p.model} onChange={(ev) => set('model', ev.target.value as Model)}>
{['haiku', 'sonnet', 'opus', 'fable'].map((m) => <option key={m} value={m}>{m}</option>)}
</select>
</label>
<label className="flex flex-col gap-1 text-sm">
<span className="font-semibold">--effort</span>
<select className="rounded bg-slate-900 p-1 font-mono" value={p.effort} onChange={(ev) => set('effort', ev.target.value as Effort)}>
{['low', 'medium', 'high', 'xhigh', 'max'].map((m) => <option key={m} value={m}>{m}</option>)}
</select>
</label>
<label className="flex items-center gap-2 text-sm">
<input type="checkbox" checked={p.smarterSubagent} onChange={(ev) => set('smarterSubagent', ev.target.checked)} />
każ subagentowi sprawdzić odpowiedź dla pewności
</label>
</div>
<pre className="overflow-x-auto whitespace-pre-wrap rounded bg-slate-900 p-2 font-mono text-xs">{command(p)}</pre>
<section className="grid gap-2 text-sm md:grid-cols-2">
<p className="rounded border border-slate-700 p-2">
Zwykle: {fmt(e.expectedRuns)} x próba{e.expectedUsd !== null ? ' = ' + fmt(e.expectedUsd) + ' USD szacunku' : ''}
</p>
<p className="rounded border border-slate-700 p-2">
Najgorzej (każdy przebieg do limitu): {fmt(e.worstRuns)} x próba{e.worstUsd !== null ? ' = ' + fmt(e.worstUsd) + ' USD szacunku' : ''}
</p>
</section>
{e.suggestedBudget !== null ? (
<p className="text-sm">Propozycja limitu: koszt próby razy dwa, czyli --max-budget-usd {e.suggestedBudget}.</p>
) : null}
<p className="text-xs text-slate-400">Kwoty to szacunek Claude Code według cen katalogowych, nie faktura. Zmiana modelu albo effort to nowa próba.</p>
<ul className="space-y-1 text-sm">
{findings.map((f) => (
<li key={f.text} className={LEVEL_CLASS[f.level]}>{f.level}: {f.text}</li>
))}
</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. Limit planu znika w połowie tygodnia, choć pracujesz jak zwykle. Od czego zaczynasz?
2. Co podnosi koszt, a nie poprawia odpowiedzi?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj kroki, zanim puścisz generate-tests.sh z --max-budget-usd na wszystkie pliki: