Kurs vibe coding z Claude Code · Moduł 13: Klon Twitcha

Pipeline pod banderą: CI napisane przez Claude Code

8 min czytania
W tej lekcji7

Skrzynia jest spakowana ale w porcie została jeszcze jedna dziura. Ty przed każdym commitem uruchamiasz lint, testy i build, bo masz to w nawyku. Bosman się spieszy: wypycha na main zmianę, której nie zbudował, i rano nikt nie może wypłynąć. Potrzebujesz latarnika, który sprawdza każdy statek, zanim wejdzie do portu, bez względu na to, kto nim płynie.

Tym latarnikiem jest CI (continuous integration, czyli ciągła integracja): przy każdej zmianie serwer sam uruchamia te same sprawdzenia, które robisz lokalnie. Na GitHubie robi to GitHub Actions. Instrukcję zapisujesz w pliku YAML w folderze .github/workflows/, a taki plik nazywa się workflow. Wynik widać przy commicie i przy pull requeście, który znasz z lekcji 1_5 jako prośbę o wlanie gałęzi z miejscem na przegląd kodu: zielony znaczek albo czerwony krzyżyk.

Czego się nauczysz

  • opisać Claude Code cel sprawdzania zamiast dyktować YAML i kazać mu sprawdzić wersje akcji, zamiast zgadywać;
  • przeczytać workflow klucz po kluczu: on, permissions, jobs, steps;
  • rozpoznać zielony test, który niczego nie testuje;
  • uruchomić Claude Code bez rozmowy, przez claude -p, z wąskimi uprawnieniami i wynikiem w JSON;
  • trzymać token wdrożenia w sekretach repozytorium, a nie w poleceniu.

Polecenie dla Claude Code

Polecenie mówi, co ma się dziać i kiedy, a nie jak ma wyglądać plik. Najważniejsze są w nim dwa zdania: o wersjach akcji i o brakującym skrypcie.

Polecenie dla Claude Code:

Dodaj workflow GitHub Actions w .github/workflows/ci.yml: przy pushu
i pull requeście na main zainstaluj zależności (npm ci), uruchom lint,
testy jednym przebiegiem i build. Sprawdź przez gh najnowsze wydania
actions/checkout i actions/setup-node i użyj ich głównych wersji,
a Node.js w aktualnej wersji LTS. Token workflow tylko do odczytu.
Jeśli w package.json brakuje któregoś skryptu, napisz mi o tym,
zamiast go wymyślać. Wdrożenie na razie pomiń.
Będzie gotowe, gdy: ci.yml się parsuje, a npm ci, npm run lint,
npm run test -- --run i npm run build przechodzą lokalnie.

Wersji akcji agent nie zna. Pamięta te z tekstów, na których się uczył, a przykłady w sieci często stoją kilka wydań z tyłu. Dlatego każesz mu sprawdzić, a on poprosi o zgodę na komendę gh z lekcji 1_5:

gh api repos/actions/checkout/releases/latest --jq .tag_name

gh api pyta API GitHuba o najnowsze wydanie repozytorium akcji, a --jq .tag_name wycina z odpowiedzi samą nazwę wersji. Tak samo dla actions/setup-node. U nas wyszło v7.0.1 i v7.1.0, więc workflow używa @v7, a aktualny Node.js LTS to 26 (stan na listopad 2026).

Co napisał Claude: workflow klucz po kluczu

Otwórz w Cursorze .github/workflows/ci.yml. Na górze stoi nazwa i to, kiedy workflow rusza:

name: CI

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

on mówi, jakie zdarzenia uruchamiają workflow: tu push na main i pull request skierowany do main. Push na inną gałąź sam niczego nie uruchomi; sprawdzenie ruszy, gdy otworzysz z niej pull request, i powtórzy się przy każdym kolejnym commicie w tym pull requeście. Dalej uprawnienia:

permissions:
  contents: read

permissions ustawia, co może token, który GitHub daje workflow na czas przebiegu (GITHUB_TOKEN). Dokumentacja GitHuba radzi zostawić minimum, a gdy wymienisz choć jedno uprawnienie, wszystkie niewymienione dostają none. Nasz workflow tylko czyta kod, więc niczego nie zapisze w repozytorium, nawet gdyby ktoś podrzucił mu złośliwy krok. Teraz właściwa praca:

jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
      - uses: actions/setup-node@v7
        with:
          node-version: 26

jobs to lista zadań; nasze jedno nazywa się check, a runs-on wybiera maszynę, na której GitHub je uruchomi. steps to kroki tego zadania, wykonywane po kolei. uses uruchamia gotową akcję: checkout pobiera kod repozytorium na maszynę, a setup-node instaluje Node.js w wersji z node-version. Na końcu cztery komendy:

      - run: npm ci
      - run: npm run lint
      - run: npm run test -- --run
      - run: npm run build

run wykonuje komendę w powłoce maszyny. Gdy krok zawiedzie, zadanie kończy się błędem, a kolejne kroki nie ruszają. --run każe Vitestowi zrobić jeden przebieg i wyjść. GitHub ustawia na swoich maszynach zmienną CI=true, a według dokumentacji Vitest w CI sam przechodzi w jeden przebieg, ale zapis wprost działa tak samo u Ciebie i stoi już w CLAUDE.md z lekcji 12_1. U nas plik się sparsował, a wszystkie cztery komendy przeszły lokalnie z CI=true.

Zielone kłamstwo

Nasz klon ma Vitest od lekcji 12_1, ale wiele projektów nie ma testów wcale. Wtedy krok testów kończy się na samym starcie, tak jak u nas w projekcie bez skryptu test:

npm error Missing script: "test"

Typowy błąd agenta to "naprawa" w package.json: skrypt "test": "exit 0" albo "test": "echo ok". Workflow świeci wtedy na zielono, a nie sprawdza niczego. Dlatego polecenie każe o brakującym skrypcie powiedzieć. W diffie poznasz tę sztuczkę od razu: package.json zmieniony w tym samym kroku co workflow, choć nikt nie prosił o nowe skrypty.

Sprawdzian przed pushem: claude -p

Workflow uruchomi się dopiero na GitHubie. Zanim wypchniesz plik, możesz zlecić Claude szybkie porównanie workflow ze skryptami, i to bez otwierania rozmowy. Tryb nieinteraktywny, claude -p, przyjmuje jedno polecenie, wypisuje wynik i kończy pracę. Dokumentacja nazywa go Agent SDK w wierszu poleceń: ten sam agent i te same narzędzia, tylko bez okna. Wpisz w osobnej karcie terminala, w folderze projektu:

claude -p "Porównaj kroki run w .github/workflows/ci.yml ze skryptami w package.json i wypisz brakujące skrypty." --allowedTools "Read" --permission-mode dontAsk --max-turns 3 --output-format json

Każda flaga zawęża pole manewru:

  • --allowedTools "Read" wymienia narzędzia, których Claude używa bez pytania;
  • --permission-mode dontAsk odrzuca każde wywołanie, które w zwykłej sesji czekałoby na Twoją zgodę; dokumentacja poleca ten tryb do zamkniętych przebiegów w CI, gdzie nikt nie odpowie na pytanie;
  • --max-turns 3 ogranicza liczbę tur agenta, a domyślnie limitu nie ma;
  • --output-format json zwraca wynik jako JSON zamiast samego tekstu.

W JSON tekst odpowiedzi stoi w polu result. Obok są inne pola warte uwagi: num_turns (liczba tur), total_cost_usd (szacunek kosztu według cennika API, a nie rachunek) i permission_denials, czyli lista wywołań, które tryb dontAsk odrzucił. U nas przebieg trwał około 18 sekund i zużył trzy tury. W result Claude wypisał tabelę: każdy krok run ma swój skrypt, a npm ci żadnego nie potrzebuje. Dorzucił uwagę, że CI nie uruchamia npx tsc --noEmit z CLAUDE.md; next build i tak sprawdza typy, co widać w jego logu jako Running TypeScript. Pole permission_denials było puste, a przy innym poleceniu trafiła do niego komenda node -e, którą Claude próbował uruchomić, zanim sięgnął po Read. Szacunek kosztu wyniósł około pół dolara, więc nawet krótki automat nie jest darmowy. W skrypcie samą odpowiedź wyciąga program jq, na przykład jq -r '.result', jak pokazuje dokumentacja.

Przegląd kapitana

  1. Wersje. uses: wskazuje te same główne wersje, które pokazał gh api, a node-version to bieżący LTS. Agent z pamięci wpisuje wersje sprzed kilku lat.
  2. Uprawnienia. Jest permissions z contents: read.
  3. Skrypty. Każdy krok run ma swój skrypt w package.json, a krok testów kończy się sam dzięki --run.
  4. Sekrety. W pliku nie ma żadnego tokena ani hasła.

Prawdziwy sprawdzian odbywa się na GitHubie. Poproś Claude: "Utwórz gałąź ci, zrób commit, wypchnij ją i otwórz przez gh pull request do main". Na stronie pull requesta pojawi się sprawdzenie CI. Kliknij je, a zobaczysz log każdego kroku. Czerwony krzyżyk to nie wstyd, tylko latarnia, która działa: przeczytaj, który krok zawiódł, i daj Claude ten fragment logu.

Następny krok

Gdy CI świeci na zielono, scal pull request. Kolejny krok to wdrożenie z workflow, i tu kapitan stawia twardą zasadę: token Vercela nie trafia do polecenia, do pliku ani do rozmowy. To, co wpiszesz w polecenie, staje się częścią rozmowy, a stamtąd może trafić do kodu, commita albo logu, jak treść pliku .env w lekcji 8_4. Tworzysz go sam w panelu Vercela i sam dodajesz na GitHubie: w repozytorium Settings, potem Secrets and variables, Actions i New repository secret, nazwa VERCEL_TOKEN. Poradnik Vercela o GitHub Actions wymaga jeszcze dwóch sekretów, VERCEL_ORG_ID i VERCEL_PROJECT_ID, z pliku .vercel/project.json, który tworzy vercel link. Potem prosisz:

Polecenie dla Claude Code:

Dodaj wdrożenie podglądu na Vercel według poradnika Vercela
o GitHub Actions. Token czytaj z sekretu VERCEL_TOKEN, identyfikatory
z VERCEL_ORG_ID i VERCEL_PROJECT_ID. Wartości sekretów nie potrzebujesz
i o nie nie pytaj.

W pliku od Claude szukaj odwołań do sekretów zamiast wartości, na przykład w takiej linii z poradnika Vercela:

run: vercel pull --yes --environment=preview --token=${{ secrets.VERCEL_TOKEN }}

Zapis ${{ secrets.VERCEL_TOKEN }} GitHub zamienia na wartość dopiero na swojej maszynie, w trakcie przebiegu. Dokumentacja GitHuba dodaje, że sekrety nie trafiają do workflow uruchomionych z forków, czyli kopii repozytorium u innych osób. Jeśli w lekcji 10_5 zaimportowałeś repozytorium w panelu Vercela, Vercel wdraża już sam po każdym pushu: wybierz jedną drogę, nie obie. W edytorze poniżej czeka czytnik workflow: klikaj klucze i puść symulowany przebieg z brakującym skryptem albo z zielonym kłamstwem agenta.

Zapamiętaj: latarnia nie steruje statkiem, ale każdej nocy sprawdza, czy ten bezpiecznie dobije do portu.

Kod do tej lekcji: App.tsx
// Czytnik workflow CI: co znaczą klucze ci.yml i co pokaże przebieg na GitHubie
import { useState } from 'react';

type KeyName = 'on' | 'permissions' | 'jobs' | 'steps';
type TestScript = 'vitest' | 'none' | 'fake';
type StepStatus = 'ok' | 'fail' | 'skipped';

interface StepResult {
  name: string;
  status: StepStatus;
  log: string;
}

const WORKFLOW: { text: string; key?: KeyName }[] = [
  { text: 'name: CI' },
  { text: 'on:', key: 'on' },
  { text: '  push:', key: 'on' },
  { text: '    branches: [main]', key: 'on' },
  { text: '  pull_request:', key: 'on' },
  { text: '    branches: [main]', key: 'on' },
  { text: 'permissions:', key: 'permissions' },
  { text: '  contents: read', key: 'permissions' },
  { text: 'jobs:', key: 'jobs' },
  { text: '  check:', key: 'jobs' },
  { text: '    runs-on: ubuntu-latest', key: 'jobs' },
  { text: '    steps:', key: 'steps' },
  { text: '      - uses: actions/checkout@v7', key: 'steps' },
  { text: '      - uses: actions/setup-node@v7', key: 'steps' },
  { text: '        with:', key: 'steps' },
  { text: '          node-version: 26', key: 'steps' },
  { text: '      - run: npm ci', key: 'steps' },
  { text: '      - run: npm run lint', key: 'steps' },
  { text: '      - run: npm run test -- --run', key: 'steps' },
  { text: '      - run: npm run build', key: 'steps' },
];

const EXPLAIN: Record<KeyName, string> = {
  on: 'on: kiedy workflow rusza. Tu przy pushu na main i przy pull requeście skierowanym do main.',
  permissions: 'permissions: co może token przebiegu. contents: read pozwala tylko czytać kod; reszta uprawnień dostaje none.',
  jobs: 'jobs: zadania workflow. Jedno zadanie check, a runs-on wybiera maszynę, na której GitHub je uruchomi.',
  steps: 'steps: kroki zadania, po kolei. uses uruchamia gotową akcję, run wykonuje komendę w powłoce.',
};

export function simulateRun(testScript: TestScript, lintError: boolean): StepResult[] {
  const plan: { name: string; run: () => { ok: boolean; log: string } }[] = [
    { name: 'actions/checkout', run: () => ({ ok: true, log: 'Kod pobrany na maszynę' }) },
    { name: 'actions/setup-node', run: () => ({ ok: true, log: 'Node.js 26 gotowy' }) },
    { name: 'npm ci', run: () => ({ ok: true, log: 'Zależności według package-lock.json' }) },
    {
      name: 'npm run lint',
      run: () => (lintError ? { ok: false, log: 'eslint zgłosił błąd w components/LiveChat.tsx' } : { ok: true, log: 'eslint bez błędów' }),
    },
    {
      name: 'npm run test -- --run',
      run: () => {
        if (testScript === 'none') return { ok: false, log: 'npm error Missing script: "test"' };
        if (testScript === 'fake') return { ok: true, log: '> exit 0 (żaden test się nie uruchomił)' };
        return { ok: true, log: 'Testy przeszły: jeden przebieg i koniec' };
      },
    },
    { name: 'npm run build', run: () => ({ ok: true, log: 'Compiled successfully' }) },
  ];

  const results: StepResult[] = [];
  let failed = false;
  for (const step of plan) {
    if (failed) {
      results.push({ name: step.name, status: 'skipped', log: 'Pominięty, bo wcześniejszy krok zawiódł' });
      continue;
    }
    const outcome = step.run();
    results.push({ name: step.name, status: outcome.ok ? 'ok' : 'fail', log: outcome.log });
    if (!outcome.ok) failed = true;
  }
  return results;
}

export function verdict(results: StepResult[], testScript: TestScript): string {
  if (results.some((r) => r.status === 'fail')) return 'Czerwony krzyżyk: przeczytaj log kroku, który zawiódł';
  if (testScript === 'fake') return 'Zielony znaczek, ale testy niczego nie sprawdziły: zielone kłamstwo';
  return 'Zielony znaczek: lint, testy i build przeszły';
}

const STATUS_LABEL: Record<StepStatus, string> = { ok: 'OK', fail: 'Błąd', skipped: 'Pominięty' };
const STATUS_CLASS: Record<StepStatus, string> = { ok: 'text-emerald-400', fail: 'text-red-400', skipped: 'text-zinc-500' };

export default function App() {
  const [active, setActive] = useState<KeyName>('on');
  const [testScript, setTestScript] = useState<TestScript>('vitest');
  const [lintError, setLintError] = useState(false);
  const results = simulateRun(testScript, lintError);

  return (
    <div className="min-h-screen space-y-4 bg-zinc-950 p-4 text-zinc-100">
      <h1 className="text-xl font-bold">Czytnik workflow: ci.yml</h1>
      <div className="grid gap-4 md:grid-cols-2">
        <pre className="overflow-x-auto rounded bg-zinc-900 p-2 font-mono text-xs leading-5">
          {WORKFLOW.map((line, i) => (
            <div key={i}>
              {line.key ? (
                <button
                  type="button"
                  onClick={() => setActive(line.key as KeyName)}
                  aria-pressed={active === line.key}
                  className={active === line.key ? 'w-full bg-purple-900 text-left whitespace-pre' : 'w-full text-left whitespace-pre'}
                >
                  {line.text}
                </button>
              ) : (
                <span className="whitespace-pre text-zinc-400">{line.text}</span>
              )}
            </div>
          ))}
        </pre>
        <section className="space-y-2 text-sm">
          <h2 className="font-semibold">Klucz: {active}</h2>
          <p>{EXPLAIN[active]}</p>
          <p className="text-zinc-400">Kliknij linię pliku, żeby zobaczyć, za co odpowiada jej klucz.</p>
        </section>
      </div>

      <fieldset className="space-y-1 text-sm">
        <legend className="font-semibold">Skrypt test w package.json</legend>
        <label className="flex items-center gap-2">
          <input type="radio" name="test" checked={testScript === 'vitest'} onChange={() => setTestScript('vitest')} />
          {'"test": "vitest" (projekt z lekcji)'}
        </label>
        <label className="flex items-center gap-2">
          <input type="radio" name="test" checked={testScript === 'none'} onChange={() => setTestScript('none')} />
          brak skryptu test
        </label>
        <label className="flex items-center gap-2">
          <input type="radio" name="test" checked={testScript === 'fake'} onChange={() => setTestScript('fake')} />
          {'Wersja agenta: "test": "exit 0"'}
        </label>
        <label className="flex items-center gap-2 pt-2">
          <input type="checkbox" checked={lintError} onChange={(e) => setLintError(e.target.checked)} />
          Bosman wypchnął kod z błędem składni
        </label>
      </fieldset>

      <ol className="space-y-1 text-sm">
        {results.map((r) => (
          <li key={r.name} className="rounded border border-zinc-800 p-2">
            <strong className={STATUS_CLASS[r.status]}>{STATUS_LABEL[r.status]}</strong> {r.name}
            <p className="font-mono text-xs text-zinc-400">{r.log}</p>
          </li>
        ))}
      </ol>
      <p role="status" className="font-semibold">{verdict(results, testScript)}</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. Co robi workflow CI napisany w lekcji?

  2. 2. Jakie zdarzenia uruchamiają workflow CI z lekcji (sekcja on:)?

Zadania praktyczne w grze

  • Układanie w pionie

    Uporządkuj kroki (steps) zadania check w workflow CI:

  • Układanie w poziomie

    Ułóż odwołanie do tokena Vercel z sekretów (jedna linia): ${{ secrets.VERCEL_TOKEN }}

  1. PytanieQuiz: co robi workflow CI
  2. PytanieQuiz: kiedy rusza workflow CI
  3. Ułóż w kolejnościSortowanie: kroki zadania CI
  4. Ułóż w kolejnościSortowanie: odwołanie do sekretu

Przydatne artykuły