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

Koszty, limity i wybór modelu

7 min czytania
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 cancel

Limit 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.json

Kwoty 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" || continue

Kwota 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 low

W 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;
  • max albo Fable na rutynie, którą i tak sprawdzi tsc;
  • zapomniana pętla /loop w długiej rozmowie;
  • skille, pluginy i serwery MCP, których nie używasz, a które płyną z każdą turą;
  • /compact w ogromnej sesji, gdy historia nie jest Ci potrzebna: /clear nic nie kosztuje.

Przegląd kapitana

  1. Każdy claude -p w skryptach ma --model, --max-turns i --max-budget-usd.
  2. Bez flagowców na rutynie. W skryptach nie ma --model fable ani --effort max.
  3. Logowanie. claude auth status --text pokazuje subskrypcję, gdy na nią liczysz, a env | grep ANTHROPIC_API_KEY nic nie wypisuje.
  4. Pętle. Część Loops w /usage nie 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. 1. Limit planu znika w połowie tygodnia, choć pracujesz jak zwykle. Od czego zaczynasz?

  2. 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:

  1. PytanieQuiz: Gdy zadanie kosztuje za dużo
  2. PytanieQuiz: Koszt bez lepszej odpowiedzi
  3. Ułóż w kolejnościSortowanie: Limit budżetu dla pętli
  4. PytanieQuiz: Zatwierdzony klucz API

Przydatne artykuły