Kurs vibe coding z Claude Code · Moduł 10: Klon TikToka

Dźwięki i nagrywarka: dwie sesje Claude Code naraz w worktree

9 min czytania
W tej lekcji12

Feed gra ale załoga chce więcej: nagrać piętnaście sekund przygody i podłożyć pod nią szantę. To dwie funkcje: biblioteka dźwięków, w której wybierasz szantę, i nagrywarka, która włącza kamerę. Nie zależą od siebie i nie dzielą plików, więc mogą powstawać jednocześnie, w dwóch sesjach Claude Code, jak dwie szalupy spuszczone z jednego okrętu.

Czego się nauczysz

  • rozpoznać, kiedy dwie funkcje można budować równolegle, a kiedy lepiej po kolei;
  • uruchomić dwie sesje claude -w i obejrzeć w Cursorze oba osobne katalogi;
  • przeczytać nagrywarkę: kamera po kliknięciu, limit, który naprawdę działa, kamera wyłączona przy wyjściu;
  • wlać dwie gałęzie do main i posprzątać po szalupach.

Worktree w jednym akapicie

Git worktree to osobny katalog roboczy z własnymi plikami i własną gałęzią, który dzieli z głównym katalogiem tę samą historię. Według dokumentacji Claude Code claude -w <nazwa> (pełna nazwa flagi to --worktree) zakłada taki katalog w .claude/worktrees/<nazwa>/ na nowej gałęzi worktree-<nazwa> i uruchamia w nim sesję. Dwie sesje w dwóch worktree edytują dwie osobne kopie plików, więc nie nadpisują sobie nawzajem zmian. Spotkają się dopiero przy scalaniu gałęzi.

Kiedy nie pracować równolegle

Izolacja kończy się przy scalaniu. Jeśli obie sesje zmienią ten sam fragment tego samego pliku, Git nie zgadnie, która wersja jest dobra. U nas dwie gałęzie, które dopisały różne funkcje na końcu lib/format.ts, skończyły scalanie tak:

Auto-merging lib/format.ts
CONFLICT (content): Merge conflict in lib/format.ts
Automatic merge failed; fix conflicts and then commit the result.

Dlatego równolegle puszczasz tylko zadania, które dotykają różnych plików, a zadania zależne robisz po kolei. Edytor klipów z lekcji 9_3 potrzebuje gotowego nagrania z nagrywarki, więc czeka. Dokumentacja przypomina też, że kilka sesji naraz zużywa wielokrotnie więcej tokenów niż jedna.

Przed wypłynięciem

Zacznij od czystej listy w Source Control i commita z feedem. Potem trzy sprawy:

  1. Katalog worktree poza Gitem. Dokumentacja radzi dopisać .claude/worktrees/ do .gitignore, żeby kopie projektu nie wisiały w głównym katalogu jako nieśledzone pliki. Poproś o to Claude i zrób commit.
  2. Najpierw push. Gdy projekt ma zdalne repozytorium, na przykład na GitHubie, nowy worktree startuje od gałęzi domyślnej z tego repozytorium, a nie od Twojego ostatniego lokalnego commita. U nas worktree założony przed pushem nie miał najnowszego commita z main. Wyślij więc main (push), zanim wypłyniesz. Projekt bez zdalnego repozytorium startuje od Twojego bieżącego commita.
  3. Sekrety. Worktree to świeży checkout, więc nie ma w nim plików z .gitignore, takich jak .env.local. Treasure Reels jeszcze ich nie ma. Gdy się pojawią, dopiszesz je do pliku .worktreeinclude w katalogu projektu, a Claude będzie je kopiował do każdego nowego worktree.

Dwie sesje

W Cursorze otwórz drugi terminal przyciskiem + w panelu terminala. W pierwszym terminalu uruchom sesję dźwięków:

claude -w dzwieki

W drugim terminalu tak samo, z inną nazwą: claude -w nagrywarka. Nazwa po -w to nazwa katalogu i końcówka gałęzi, więc wybierz krótką i opisową. W świeżym worktree nie ma też folderu node_modules: u nas ls node_modules odpowiedziało No such file or directory. Dlatego oba polecenia zaczynają się od instalacji zależności.

Polecenie dla Claude Code (sesja dzwieki):

Pracujesz w osobnym worktree nad biblioteką dźwięków Treasure Reels.
Najpierw zainstaluj zależności (npm install). Potem: typ SoundDetails
w types/sound.ts, który rozszerza Sound z @types/video.ts (nie kopiuj
go), dane w lib/sounds.ts (pliki z public/sounds), strona
app/dzwieki/page.tsx z wyszukiwarką po tytule i zakładkami "Na fali"
i "Wszystkie", odsłuch na karcie: naraz gra tylko jeden dźwięk.
Nie ruszaj app/layout.tsx, app/page.tsx ani components/ForYouFeed.tsx.
Na koniec lint, typy, testy i build, potem commit.

Do drugiego terminala trafia polecenie nagrywarki. Jest dłuższe, bo nagrywarka ma więcej miejsc, w których coś może zostać włączone na zawsze albo nigdy się nie skończyć.

Polecenie dla Claude Code (sesja nagrywarka):

Pracujesz w osobnym worktree nad nagrywarką Treasure Reels. Najpierw
zainstaluj zależności (npm install). Zrób components/VideoRecorder.tsx
i stronę app/nagraj/page.tsx: kamera i mikrofon dopiero po kliknięciu
"Włącz kamerę", podgląd na żywo, nagrywanie przez MediaRecorder
z limitem maxSeconds (domyślnie 15), które samo się zatrzymuje, pasek
czasu, komunikat przy odmowie dostępu, kamera wyłączona po wyjściu
ze strony, wynik przez onComplete(blob, { durationSec, mimeType })
z prawdziwym czasem nagrania. Format dobierz przez
MediaRecorder.isTypeSupported. Nie ruszaj app/layout.tsx, app/page.tsx
ani types/video.ts. Dopisz test z udawaną kamerą: nagranie kończy się
samo po limicie. Na koniec lint, typy, testy i build, potem commit.

Zdania "nie ruszaj" wyznaczają granicę między szalupami: pliki wspólne zostają nietknięte, a linki do nowych stron dodasz po scaleniu. U nas obie sesje pracowały równocześnie, każda po kilka minut. Obie zgłosiły przy tym ten sam kłopot: w świeżym worktree npx tsc --noEmit zgłasza błąd Cannot find name 'LayoutProps', bo typy tras leżą w folderze .next, którego checkout nie ma. Znikają po npx next typegen albo po pierwszym buildzie.

W Cursorze: dwa katalogi

Rozwiń w drzewie plików .claude/worktrees/. Leżą tam dzwieki i nagrywarka, każdy z pełną kopią projektu. Zmiana w jednym nie pojawia się ani w drugim, ani w głównym katalogu, aż do scalenia. Otwórz .claude/worktrees/dzwieki/types/sound.ts:

import type { Sound } from "@/types/video";

export interface SoundDetails extends Sound {
  src: string; // "/sounds/hymn.m4a"
  uses: number; // liczba filmów nagranych z tym dźwiękiem
  trending: boolean; // trafia do zakładki "Na fali"
}

extends bierze wszystkie pola Sound z lekcji 9_1 i dokłada trzy nowe, więc dźwięk ma jedną definicję w całym projekcie. Odsłuch działa jak feed: efekt na playingId odtwarza wybrany <audio>, a każdy inny pauzuje. Claude wykorzystał też to, o czym była mowa przy referencjach: funkcja ref karty zwraca funkcję sprzątającą, która usuwa dźwięk z mapy, gdy karta znika z listy.

Co napisał Claude: format nagrania

Teraz .claude/worktrees/nagrywarka/components/VideoRecorder.tsx. Przeglądarki nagrywają w różnych formatach, więc format wybiera mała funkcja:

const MIME_CANDIDATES = [
  "video/webm;codecs=vp9,opus",
  "video/webm;codecs=vp8,opus",
  "video/webm",
  "video/mp4;codecs=avc1,mp4a.40.2",
  "video/mp4",
];

export function pickMimeType(): string | undefined {
  if (typeof MediaRecorder === "undefined" || typeof MediaRecorder.isTypeSupported !== "function") {
    return undefined;
  }
  return MIME_CANDIDATES.find((type) => MediaRecorder.isTypeSupported(type));
}

MediaRecorder to wbudowane w przeglądarkę narzędzie, które nagrywa strumień z kamery do pliku. Według MDN isTypeSupported mówi, czy przeglądarka potrafi nagrywać w danym formacie, a konstruktor z formatem, którego nie zna, rzuca NotSupportedError. Gdy żaden kandydat nie pasuje, funkcja zwraca undefined i format wybiera przeglądarka. Prawdziwy format nagrania podaje potem właściwość recorder.mimeType, i to on trafia do metadanych.

Co napisał Claude: kamera po kliknięciu

Prośba o kamerę stoi w funkcji obsługi przycisku, nigdy w samym rysowaniu, jak mikrofon w lokacji 9. Oto jej serce, w skrócie:

try {
  const media = await navigator.mediaDevices.getUserMedia({
    video: { facingMode: "user" },
    audio: true,
  });
  setStream(media);
} catch (err) {
  setError(cameraErrorMessage(err));
}

cameraErrorMessage zamienia nazwę błędu na zdanie po polsku. MDN opisuje trzy najczęstsze: NotAllowedError przy odmowie, NotFoundError, gdy nie ma kamery, i NotReadableError, gdy kamerę trzyma inna aplikacja. Kamerę zwalnia ten sam wzór co mikrofon w lokacji 9: efekt kluczowany strumieniem, którego sprzątanie wywołuje stop() na każdej ścieżce. Dodatkowy efekt przy wyjściu ze strony urywa trwające nagranie bez oddawania wyniku.

Co napisał Claude: limit, który działa

Zegar nagrania liczy czas od zapisanego startu i sam woła zatrzymanie:

timerRef.current = setInterval(() => {
  const ms = Date.now() - startedAt;
  setElapsed(Math.min(ms / 1000, maxSeconds));
  if (ms >= maxSeconds * 1000) stopRecording();
}, 100);

Funkcja w setInterval zapamiętuje zmienne z chwili, w której powstała. Ta czyta tylko czas startu i limit, które się nie zmieniają, więc nic w niej się nie starzeje. stopRecording najpierw sprząta interwał, a potem zatrzymuje nagrywanie, ale tylko wtedy, gdy jeszcze trwa:

const recorder = recorderRef.current;
if (recorder && recorder.state !== "inactive") recorder.stop();

Ten warunek nie jest ozdobą. Według MDN stop() na nieaktywnym nagrywaniu rzuca InvalidStateError, a kliknięcie Zatrzymaj i limit mogą przyjść w tej samej chwili. Po stop() przychodzi zdarzenie stop, w którym Claude składa wynik:

recorder.onstop = () => {
  const durationSec = (Date.now() - startedAt) / 1000;
  const mimeType = recorder.mimeType || preferred || "";
  const blob = new Blob(chunks, mimeType ? { type: mimeType } : undefined);
  onCompleteRef.current(blob, { durationSec, mimeType });
};

durationSec to zmierzony czas od startu do zatrzymania, a nie liczba z ustawień, więc edytor w lekcji 9_3 dostanie prawdziwą długość klipu.

Przegląd kapitana

  1. Stary stan w interwale. Typowy błąd agenta to warunek if (isRecording && ...) w interwale. isRecording w tej funkcji ma wartość z chwili startu, czyli false, więc nagrywanie nigdy nie kończy się samo. U nas taka wersja przeszła lint, tsc i build, a test z udawanym zegarem ją oblał linią expected "vi.fn()" to be called once, but got 0 times. Szukasz w interwale zmiennych stanu.
  2. Kamera zgaszona. Wyszukaj w pliku getTracks, clearInterval i revokeObjectURL (strona tworzy adres podglądu nagrania). Brak któregoś to wyciek: lampka kamery świeci po wyjściu ze strony albo pamięć rośnie z każdym nagraniem.
  3. Odmowa. Kliknij "Włącz kamerę" i odmów dostępu. U nas przeglądarka z zablokowaną kamerą pokazała komunikat "Odmówiono dostępu do kamery i mikrofonu.", a nie pusty ekran.
  4. Zakres. Lista plików w commicie każdej sesji. Sesja dźwięków dopisała u nas formatDuration do wspólnego lib/format.ts. Tym razem nagrywarka tego pliku nie ruszyła, więc scalenie przeszło, ale to dokładnie ten rodzaj zmiany, który kończy się konfliktem.

Scalanie i sprzątanie

Wróć do głównego katalogu: trzeci terminal, zwykłe claude, i polecenie "Wlej do main gałęzie worktree-dzwieki i worktree-nagrywarka, po kolei, potem lint, testy i build". U nas pierwsza gałąź weszła jako Fast-forward, bo main od jej startu się nie zmienił, a druga dostała commit scalający z linią Merge made by the 'ort' strategy..

Teraz sprzątanie. Dopóki worktree leżą w projekcie, narzędzia z głównego katalogu je widzą: u nas npm run lint zgłosił 7056 problems (364 errors, 6692 warnings) z folderów .next w worktree, a Vitest uruchomił 12 plików testów zamiast 5, bo doliczył kopie z obu worktree. Wyjdź z obu sesji przez /exit. Według dokumentacji, gdy worktree ma zmiany albo nowe commity, Claude pyta, czy go zachować, czy usunąć. Usunięcie kasuje katalog i gałąź razem z pracą, dlatego wybierasz je dopiero po scaleniu. Jeśli wolisz trzymać worktree dłużej, poproś Claude o dopisanie .claude/worktrees/** do ignorowanych ścieżek w eslint.config.mjs i w vitest.config.mts.

Następny krok

Linki do /dzwieki i /nagraj w nawigacji to zmiana we wspólnym app/layout.tsx, więc robisz ją już po scaleniu, w jednej sesji. Jeśli Claude przy okazji zmieni coś poza nawigacją, /rewind z lekcji 0_6 cofnie całą turę. Potem commit, na przykład "Dźwięki i nagrywarka".

W edytorze poniżej czeka nagrywarka z udawaną kamerą i lampką. Ustaw limit 5 sekund, włącz błąd agenta ze starym stanem i zobacz, jak nagranie mija limit. Potem opuść stronę z drugim błędem i popatrz na lampkę.

Zapamiętaj: dwie szalupy płyną szybciej niż jedna tylko wtedy, gdy każda wiosłuje do innej zatoki, a kto nie zgasi latarni, ten zostawia ją świecić całą noc.

Kod do tej lekcji: App.jsx
// Nagrywarka w miniaturze: udawana kamera, prawdziwy limit i lampka kamery
import { useEffect, useRef, useState } from 'react';

const TYPES = ['video/mp4;codecs=avc1.64003E,mp4a.40.2', 'video/webm;codecs=vp8,opus', 'video/webm'];

function supported(type) {
  return typeof MediaRecorder !== 'undefined' && MediaRecorder.isTypeSupported(type);
}

function Recorder({ maxSeconds, deny, bugInterval, bugTracks, onLamp, onComplete }) {
  const [stream, setStream] = useState(null);
  const [error, setError] = useState('');
  const [recording, setRecording] = useState(false);
  const [elapsed, setElapsed] = useState(0);
  const recorderRef = useRef(null);
  const timerRef = useRef(null);
  const startedAtRef = useRef(0);

  function enableCamera() {
    setError('');
    if (deny) {
      setError('Brak dostępu do kamery. Zezwól na kamerę w ustawieniach przeglądarki.');
      return;
    }
    // udawany strumień: stop() gasi lampkę kamery; leaky to włączony błąd agenta
    setStream({ stop: () => onLamp(false), leaky: bugTracks });
    onLamp(true);
  }

  // Sprzątanie: kamera gaśnie, gdy strumień znika albo nagrywarka opuszcza ekran
  useEffect(() => {
    if (!stream) return;
    return () => {
      clearInterval(timerRef.current);
      if (!stream.leaky) stream.stop();
    };
  }, [stream]);

  function stop() {
    const recorder = recorderRef.current;
    if (!recorder || recorder.state === 'inactive') return;
    recorder.state = 'inactive';
    clearInterval(timerRef.current);
    setRecording(false);
    const durationSec = (Date.now() - startedAtRef.current) / 1000;
    const mimeType = TYPES.find(supported) || 'brak MediaRecorder w tej przeglądarce';
    onComplete({ durationSec, mimeType });
  }

  function start() {
    recorderRef.current = { state: 'recording' };
    startedAtRef.current = Date.now();
    setElapsed(0);
    setRecording(true);
    timerRef.current = setInterval(() => {
      const seconds = (Date.now() - startedAtRef.current) / 1000;
      setElapsed(seconds);
      if (bugInterval) {
        // błąd agenta: `recording` pochodzi z chwili startu, czyli false
        if (recording && seconds >= maxSeconds) stop();
      } else if (seconds >= maxSeconds) {
        stop();
      }
    }, 100);
  }

  return (
    <div className="space-y-3">
      <div className="relative flex h-56 items-center justify-center rounded-xl bg-gradient-to-br from-slate-800 to-indigo-900">
        <span className="text-lg">{stream ? 'Podgląd z kamery' : 'Kamera wyłączona'}</span>
        {recording && <span className="absolute top-3 left-3 rounded-full bg-red-600 px-3 py-1 text-xs">● REC</span>}
      </div>
      {!stream && (
        <button type="button" onClick={enableCamera} className="rounded bg-sky-600 px-4 py-2">Włącz kamerę</button>
      )}
      {error && <p role="alert" className="text-red-400">{error}</p>}
      {stream && (
        <div className="space-y-2">
          <div className="h-2 w-full overflow-hidden rounded bg-gray-700">
            <div className="h-full bg-red-500" style={{ width: `${Math.min(100, (elapsed / maxSeconds) * 100)}%` }} />
          </div>
          <p className="text-sm">{elapsed.toFixed(1)} s / {maxSeconds} s</p>
          <button
            type="button"
            onClick={recording ? stop : start}
            className="rounded bg-red-600 px-4 py-2"
          >
            {recording ? 'Zatrzymaj' : 'Nagrywaj'}
          </button>
        </div>
      )}
    </div>
  );
}

export default function App() {
  const [page, setPage] = useState('nagraj');
  const [lamp, setLamp] = useState(false);
  const [maxSeconds, setMaxSeconds] = useState(5);
  const [deny, setDeny] = useState(false);
  const [bugInterval, setBugInterval] = useState(false);
  const [bugTracks, setBugTracks] = useState(false);
  const [results, setResults] = useState([]);

  return (
    <div className="min-h-screen bg-gray-950 p-4 text-white">
      <div className="mb-4 flex flex-wrap items-center gap-3">
        <button type="button" onClick={() => setPage(page === 'nagraj' ? 'feed' : 'nagraj')} className="rounded bg-gray-700 px-4 py-2">
          {page === 'nagraj' ? 'Opuść stronę nagrywania' : 'Wróć do nagrywania'}
        </button>
        <span className={lamp ? 'text-green-400' : 'text-gray-400'}>Lampka kamery: {lamp ? 'świeci' : 'zgaszona'}</span>
      </div>
      <div className="grid gap-4 md:grid-cols-2">
        <div>
          {page === 'nagraj' ? (
            <Recorder
              maxSeconds={maxSeconds}
              deny={deny}
              bugInterval={bugInterval}
              bugTracks={bugTracks}
              onLamp={setLamp}
              onComplete={(r) => setResults((prev) => [r, ...prev])}
            />
          ) : (
            <p className="rounded-xl bg-gray-800 p-6">Feed For You. Nagrywarka zniknęła z ekranu.</p>
          )}
        </div>
        <div className="space-y-2 text-sm">
          <label className="flex items-center gap-2">
            Limit:
            <select value={maxSeconds} onChange={(e) => setMaxSeconds(Number(e.target.value))} className="rounded bg-gray-800 px-2 py-1">
              <option value={5}>5 s</option>
              <option value={15}>15 s</option>
            </select>
          </label>
          <label className="flex items-center gap-2"><input type="checkbox" checked={deny} onChange={(e) => setDeny(e.target.checked)} /> Odmów dostępu do kamery</label>
          <label className="flex items-center gap-2"><input type="checkbox" checked={bugInterval} onChange={(e) => setBugInterval(e.target.checked)} /> Błąd agenta: stary stan w interwale</label>
          <label className="flex items-center gap-2"><input type="checkbox" checked={bugTracks} onChange={(e) => setBugTracks(e.target.checked)} /> Błąd agenta: bez stop() ścieżek (zaznacz przed włączeniem kamery)</label>
          <p className="pt-2 font-bold">Formaty w Twojej przeglądarce (isTypeSupported):</p>
          <ul>
            {TYPES.map((t) => <li key={t}>{t}: {supported(t) ? 'tak' : 'nie'}</li>)}
          </ul>
          <p className="pt-2 font-bold">Nagrania:</p>
          <ul>
            {results.map((r, i) => <li key={i}>{r.durationSec.toFixed(1)} s, {r.mimeType}</li>)}
          </ul>
        </div>
      </div>
    </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 komenda claude -w dzwieki?

  2. 2. Jak typ SoundDetails korzysta z typu Sound z lekcji 9_1?

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

Zadania praktyczne w grze

  • Układanie w pionie

    Uporządkuj pracę równoległą nad dźwiękami i nagrywarką (od pierwszego kroku):

  • Układanie w poziomie

    Ułóż komendę, która uruchamia drugą sesję Claude Code w osobnym worktree o nazwie nagrywarka:

  • Edytor kodu

    Sounds discovery

  • Klikanie w kolejności

    Zbuduj warunek, który zatrzymuje nagrywanie po limicie (klikaj po kolei):

  • Klikanie w kolejności

    Zbuduj wyrażenie, które wybiera pierwszy format obsługiwany przez przeglądarkę (klikaj po kolei):

  • Układanie w poziomie

    Ułóż początek wywołania, które po kliknięciu prosi o kamerę i mikrofon:

  • Układanie w pionie

    Uporządkuj kroki nagrywania w VideoRecorder (od pierwszego):

  • Edytor kodu

    Video recording interface

  • Klikanie w kolejności

    Zbuduj utworzenie Bloba z nagranych kawałków (klikaj po kolei):

  • Układanie w poziomie

    Ułóż linię, która zatrzymuje nagrywanie tylko wtedy, gdy jeszcze trwa:

  1. PytanieCo robi claude -w
  2. PytanieSoundDetails i Sound
  3. Ułóż w kolejnościPraca równoległa krok po kroku
  4. Ułóż w kolejnościDruga sesja w worktree
  5. Zadanie z kodemPraktyka: Sounds page
  6. Kliknij w kolejnościWarunek limitu nagrania
  7. Kliknij w kolejnościWybór formatu nagrania
  8. PytanieKiedy nie pracować równolegle
  9. Ułóż w kolejnościProśba o kamerę
  10. PytanieStary stan w interwale
  11. Ułóż w kolejnościCykl nagrywania
  12. Zadanie z kodemPraktyka: Video recorder
  13. PytaniePush przed worktree
  14. Kliknij w kolejnościBlob z nagrania
  15. Ułóż w kolejnościBezpieczne stop()

Przydatne artykuły