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

Praca równoległa i w tle: worktree, zadania w tle, /batch, /loop i /schedule

9 min czytania
W tej lekcji10

Na liście Treasure Map czekają dwie funkcje. Pierwsza to tablice współdzielone: właściciel zaprasza do tablicy współpracowników, a oni zapisują na niej swoje piny. Pole collaboratorIds tablica ma od lekcji 13_2, brakuje tylko zaproszeń. Druga to lepsza lupa: wyszukiwanie po zdjęciu porównuje dziś sam dominujący kolor, a mogłoby ważyć też tagi pinów. Funkcje nie zależą od siebie, a w jednej sesji i tak stoją w kolejce: druga czeka, aż skończy się pierwsza, a w rozmowie mieszają się szczegóły obu. Ta lekcja pokazuje, kiedy rozdzielić pracę między kilka sesji, jak zostawić ją w tle i komu oddać zegar.

Co już umiesz

W lekcji 9_2 spuściłeś dwie szalupy, claude -w dzwieki i claude -w nagrywarka, każdą w katalogu .claude/worktrees/<nazwa>/ na gałęzi worktree-<nazwa>, i zobaczyłeś konflikt, gdy dwie gałęzie dopisały coś w tym samym miejscu lib/format.ts. W lekcji 6_4 przeniosłeś serwer w tło przez Ctrl+B i obejrzałeś go w /tasks, a z lekcji 5_10 wiesz, że każdy subagent płaci z tego samego limitu co rozmowa. Z lekcji 14_6 znasz sesje w chmurze, a z lekcji 14_7 przebieg claude -p --worktree, po którym worktree zostaje zablokowany. Tu dokładasz to, czego potrzebujesz, gdy równoległych zadań przybywa, a Ciebie przy nich nie ma.

Najpierw mapa plików

Dwie sesje w dwóch worktree nie nadpiszą sobie plików, ale przy scalaniu gałęzi wspólny plik i tak wypłynie. Zanim spuścisz szalupy, sprawdź więc, czy płyną do różnych zatok. Zrób to w trybie planowania, w którym Claude tylko czyta projekt:

Polecenie dla Claude Code (tryb planowania):

Nie pisz kodu. Dwie funkcje Treasure Map: (1) zaproszenia do tablicy, (2) wyszukiwanie
po zdjęciu, które oprócz koloru porównuje tagi pinów. Dla każdej wypisz pliki, które
zmieni albo utworzy, i zaznacz, czy potrzebuje migracji bazy albo nowej paczki npm.
Na końcu podaj pliki wspólne dla obu funkcji.

Lista zamiast kodu kosztuje niewiele i od razu mówi, czy praca może płynąć równolegle. Dobry plan wygląda mniej więcej tak:

1. Zaproszenia: lib/boards.ts, app/api/boards/[id]/collaborators/route.ts (nowy),
   components/InviteDialog.tsx (nowy), app/boards/[id]/page.tsx. Bez migracji i paczek.
2. Lupa: lib/visualSearch.ts, app/api/visual-search/route.ts, components/CameraSearch.tsx.
   Bez migracji i paczek.
Pliki wspólne: brak.

Pusta lista wspólnych plików to zielone światło. Trzy przypadki zatrzymują Cię w porcie, nawet gdy pliki się nie powtarzają. Pierwszy to dwie migracje: obie szalupy dostaną ten sam .env, czyli tę samą bazę, więc zmianę schematu robisz najpierw osobno, w głównym katalogu. Drugi to dwie nowe paczki, bo obie gałęzie zmienią package.json i package-lock.json. Trzeci to zależność: gdy jedna funkcja potrzebuje wyniku drugiej, płyną po kolei.

Dwie szalupy z jednym .env

W lekcji 14_7 worktree wypłynął bez .env, bo testy go nie potrzebowały. Zaproszenia czytają jednak bazę, więc tym razem plik ma płynąć z załogą. Służy do tego .worktreeinclude w katalogu głównym projektu, ze składnią .gitignore:

.env

Claude Code kopiuje do każdego nowego worktree pliki, które pasują do wzorca i są ignorowane przez Git, a plików śledzonych nigdy nie dubluje. U nas po dopisaniu tej jednej linii przebieg claude -p --worktree tablice zastał w worktree .env identyczny z oryginałem. Wzorzec obejmuje tylko .env, więc node_modules instaluje każda sesja sama, podobnie jak klienta Prisma: folder app/generated/prisma jest w .gitignore, więc świeży checkout go nie ma. Teraz dwa terminale w Cursorze, w każdym jedna komenda:

claude -w tablice
claude -w wyszukiwanie

Projekt bez zdalnego repozytorium startuje worktree od Twojego bieżącego commita. Z repozytorium na GitHubie startuje od gałęzi domyślnej z remote'a, więc robisz push, jak w lekcji 9_2, albo ustawiasz w ustawieniach "worktree": { "baseRef": "head" }. Do sesji tablic trafia polecenie z wyraźną granicą:

Polecenie dla Claude Code (sesja tablice):

Pracujesz w worktree nad zaproszeniami do tablic. Najpierw npm install i npx prisma generate.
Tylko właściciel tablicy dodaje współpracownika: trasa app/api/boards/[id]/collaborators/route.ts
ze schematem Zod i 403 dla innych, okno components/InviteDialog.tsx na stronie tablicy.
Bez migracji i bez nowych paczek. Nie ruszaj lib/visualSearch.ts, app/api/visual-search
ani components/CameraSearch.tsx. Na koniec testy, lint i tsc, potem commit.

Druga sesja dostaje lustrzane polecenie: swoje pliki z mapy i zakaz wchodzenia w pliki tablic.

Gdy sesja zrobi commit, wychodzisz z niej, a Claude Code pyta, co zrobić z worktree, w którym jest praca. Wybierz zachowanie. Usunięcie skasuje katalog razem z gałęzią i jej commitami, a tej pracy nie ma jeszcze w main.

Szalupy wracają

Zanim cokolwiek scalisz, porównaj listy zmienionych plików obu gałęzi. W terminalu głównego katalogu:

comm -12 <(git diff --name-only main...worktree-tablice | sort) <(git diff --name-only main...worktree-wyszukiwanie | sort)

git diff --name-only wypisuje pliki zmienione na gałęzi od jej rozejścia z main, a comm -12 zostawia tylko linie obecne na obu listach. Pusty wynik oznacza, że gałęzie nie zmieniły wspólnego pliku, więc Git nie zgłosi konfliktu. W próbnym repozytorium, w którym obie gałęzie ruszyły lib/types.ts, komenda wypisała dokładnie tę jedną ścieżkę. Składnia <(...) działa w bash i zsh, ale nie w PowerShellu, domyślnym terminalu Cursora na Windowsie: tam uruchom komendę w Git Bash albo poproś Claude, żeby porównał obie listy. Scalasz potem po kolei, jak w lekcji 9_2.

Po scaleniu sprzątanie. Worktree zachowane przy wyjściu z sesji usuwasz sam. Worktree z przebiegu -p jest do tego zablokowany: u nas git worktree remove odpowiedział cannot remove a locked working tree. Pełna sekwencja ma więc trzy komendy, a pierwsza jest potrzebna tylko przy blokadzie:

git worktree unlock .claude/worktrees/tablice
git worktree remove .claude/worktrees/tablice
git branch -d worktree-tablice

Skopiowany .env nie blokuje usuwania, bo Git go ignoruje. git branch -d usuwa tylko gałąź już scaloną, więc nie skasuje pracy, której jeszcze nie wlałeś.

Cała sesja w tle

Ctrl+B z lekcji 6_4 przenosi w tło jedną komendę albo subagenta. Komenda /background (krócej /bg) odłącza całą sesję: pracuje dalej jako agent w tle, a terminal wraca do Ciebie. Nową sesję w tle zaczniesz z powłoki przez claude --bg "zadanie", a wszystkie zobaczysz na jednym ekranie po claude agents, wciąż w fazie testów (research preview). Sesja wysłana przez claude --bg przenosi się do własnego worktree, zanim cokolwiek zmieni. Sesja odesłana w tło przez /background edytuje dalej tam, gdzie pracowała, więc odesłana z głównego katalogu izolacji nie ma.

/batch: jedna zmiana, wiele plików

Na dużą, mechaniczną zmianę w wielu plikach jest wbudowany skill /batch. Według dokumentacji Claude najpierw bada projekt, dzieli pracę na niezależne jednostki i pokazuje plan. Po Twojej akceptacji każda jednostka dostaje subagenta w tle i własny worktree, a subagent wprowadza zmianę, uruchamia testy i otwiera pull request albo melduje, co zrobił. Wygląda to tak:

/batch dopisz do każdego komponentu w components/ test renderowania w Vitest obok pliku komponentu

To dobry kandydat: ta sama zmiana, każdy test w osobnym pliku, każdy sprawdzalny osobno. Przy siedmiu komponentach Treasure Map to jednak armata na wróble, bo jedna sesja zrobi to taniej, a /batch zarabia na siebie przy dziesiątkach plików. Nie sięgaj po niego, gdy jednostki dotykają wspólnego pliku, gdy zmiana wymaga decyzji projektowej albo gdy projekt nie ma testów, którymi subagent sprawdzi swoją część. Pamiętaj też, że worktree subagentów startują jak claude -w, czyli przy repozytorium na GitHubie od gałęzi z remote'a.

/loop i /schedule: kto pilnuje zegara

/loop powtarza polecenie w otwartej sesji: co podany odstęp albo w tempie, które Claude dobiera sam. Na przykład meldunek o szalupach:

/loop 10m sprawdź git log -1 --oneline na gałęziach worktree-tablice i worktree-wyszukiwanie i powiedz, która sesja zrobiła już commit

Każde powtórzenie to nowa tura, która wysyła całą rozmowę, także wtedy, gdy nic się nie zmieniło, więc nie zostawiaj pętli w długiej sesji. Pętla działa tylko, gdy sesja jest otwarta, a zadanie cykliczne wygasa po siedmiu dniach (stan na listopad 2026). Pętlę z odstępem zatrzymasz, prosząc Claude o jej anulowanie, a pętlę w tempie Claude klawiszem Esc.

/schedule zakłada zadanie cykliczne w chmurze, dawniej nazywane rutyną. Każde uruchomienie to pełna sesja Claude Code na świeżym klonie repozytorium z GitHuba, więc działa przy zamkniętym laptopie, ale nie widzi Twoich niezacommitowanych plików. Wymaga logowania kontem claude.ai, a nie kluczem API, zmiany wypycha na gałęzie z przedrostkiem claude/, a dokumentacja radzi najpierw chronić main regułą gałęzi na GitHubie. Dziś niczego nie zakładasz: najpierw repozytorium i reguła dla main, potem pierwsze uruchomienia pod Twoim okiem.

/loop/schedule
Gdzie pracujew Twojej otwartej sesjiw chmurze Anthropic
Komputer wyłączonypętla stajezadanie działa
PlikiTwój katalog, także niezacommitowaneświeży klon z GitHuba
Do czegokrótkie pilnowanie w trakcie pracystałe zadania co noc albo co tydzień

Koszt równoległości

Każda sesja, sesja w tle, subagent i jednostka /batch wysyła własne zapytania i płaci z tego samego limitu planu. Dokumentacja mówi wprost: dziesięć agentów w tle zużywa limit mniej więcej dziesięć razy szybciej niż jeden. Równoległość kupuje czas, a nie oszczędność, więc puszczasz ją tam, gdzie czekanie naprawdę boli.

Przegląd kapitana

  1. Mapa bez części wspólnej. comm -12 z sekcji powyżej nic nie wypisuje.
  2. Jedna baza. Obie sesje mają ten sam DATABASE_URL, więc w diffie żadnej gałęzi nie ma nowego folderu w prisma/migrations/.
  3. Paczki. package.json i package-lock.json zmieniła najwyżej jedna gałąź.
  4. Po rejsie. git worktree list pokazuje już tylko główny katalog.

Typowy błąd agenta: dwa równoległe zadania dotykają tych samych plików. Sesja tablic "przy okazji" dopisuje link do nawigacji w app/layout.tsx albo pole w typie Pin w lib/types.ts, a druga sesja robi to samo po swojemu. Rozpoznasz to po wyniku comm -12 albo po tym pliku w diffie obu gałęzi w Cursorze. Wspólną zmianę cofasz z jednej gałęzi i robisz ją po scaleniu, w jednej sesji.

Następny krok

W sesji w głównym katalogu napisz: "Wlej do main gałęzie worktree-tablice i worktree-wyszukiwanie, po kolei, potem testy, lint i tsc". Scalenie samo zapisuje historię, więc o commit prosisz tylko wtedy, gdy testy wymusiły poprawki, na przykład "Poprawki po scaleniu tablic i lupy". Na koniec posprzątaj szalupy. W edytorze obok wpiszesz pliki dwóch zadań, a sprawdzarka powie, czy mogą płynąć równolegle, i poda komendy.

Pamiętaj: szalupy spuszczasz razem tylko wtedy, gdy każda płynie do innej zatoki, a zegar oddajesz temu, kto będzie na pokładzie, gdy wybije godzina.

Kod do tej lekcji: App.tsx
// Szalupy czy kolejka: czy dwa zadania Treasure Map mogą płynąć równolegle i kto pilnuje zegara
import { useState } from 'react';

export type Level = 'ok' | 'warn' | 'error';

export interface Finding {
  level: Level;
  text: string;
}

export interface Task {
  name: string;
  files: string;
  migration: boolean;
  packages: boolean;
}

export interface Verdict {
  parallel: boolean;
  findings: Finding[];
  commands: string[];
}

export const SHARED = ['app/layout.tsx', 'lib/types.ts', 'package.json', 'package-lock.json', 'prisma/schema.prisma'];

const PL: Record<string, string> = { ą: 'a', ć: 'c', ę: 'e', ł: 'l', ń: 'n', ó: 'o', ś: 's', ź: 'z', ż: 'z' };

export function slug(name: string): string {
  const ascii = name.toLowerCase().split('').map((ch) => PL[ch] ?? ch).join('');
  const s = ascii.replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
  return s === '' ? 'zadanie' : s;
}

export function parseFiles(text: string): string[] {
  const out: string[] = [];
  for (const raw of text.split(/[,\n]/)) {
    let f = raw.trim();
    if (f.startsWith('./')) f = f.slice(2);
    if (f !== '' && !out.includes(f)) out.push(f);
  }
  return out;
}

function touches(a: string, b: string): boolean {
  if (a === b) return true;
  if (a.endsWith('/') && b.startsWith(a)) return true;
  return b.endsWith('/') && a.startsWith(b);
}

export function overlap(a: string[], b: string[]): string[] {
  const out: string[] = [];
  for (const fa of a) {
    for (const fb of b) {
      if (touches(fa, fb)) {
        const shorter = fa.length <= fb.length ? fa : fb;
        if (!out.includes(shorter)) out.push(shorter);
      }
    }
  }
  return out.sort();
}

export function check(a: Task, b: Task, dependent: boolean): Verdict {
  const fa = parseFiles(a.files);
  const fb = parseFiles(b.files);
  const findings: Finding[] = [];
  if (fa.length === 0 || fb.length === 0) {
    findings.push({ level: 'warn', text: 'Brak mapy plików. Poproś Claude w trybie planowania o listę plików każdego zadania.' });
  }
  const common = overlap(fa, fb);
  if (common.length > 0) {
    findings.push({ level: 'error', text: 'Wspólne pliki: ' + common.join(', ') + '. Przy scalaniu wypłynie konflikt albo jedna wersja nadpisze drugą.' });
  }
  for (const s of SHARED) {
    const inA = fa.includes(s);
    const inB = fb.includes(s);
    if (inA !== inB) {
      findings.push({ level: 'warn', text: s + ' to plik całej aplikacji. Lepiej zmienić go po scaleniu, w jednej sesji.' });
    }
  }
  if (a.migration && b.migration) {
    findings.push({ level: 'error', text: 'Dwie migracje, a .env z .worktreeinclude daje obu sesjom tę samą bazę. Zmiany schematu po kolei, w głównym katalogu.' });
  } else if (a.migration || b.migration) {
    findings.push({ level: 'warn', text: 'Migracja w worktree trafi do tej samej bazy co główny katalog. Zrób ją przed rozdzieleniem pracy.' });
  }
  if (a.packages && b.packages) {
    findings.push({ level: 'error', text: 'Obie gałęzie zmienią package.json i package-lock.json.' });
  }
  if (dependent) {
    findings.push({ level: 'error', text: b.name + ' potrzebuje wyniku zadania ' + a.name + ', więc płyną po kolei.' });
  }
  const parallel = !findings.some((f) => f.level === 'error') && fa.length > 0 && fb.length > 0;
  if (parallel) {
    findings.push({ level: 'ok', text: 'Różne zatoki: każde zadanie może dostać własny worktree.' });
  }
  const wa = 'worktree-' + slug(a.name);
  const wb = 'worktree-' + slug(b.name);
  const commands = parallel
    ? [
        'claude -w ' + slug(a.name) + '    # terminal 1',
        'claude -w ' + slug(b.name) + '    # terminal 2',
        'comm -12 <(git diff --name-only main...' + wa + ' | sort) <(git diff --name-only main...' + wb + ' | sort)',
      ]
    : ['claude    # jedna sesja: najpierw ' + a.name + ', commit, potem ' + b.name];
  return { parallel, findings, commands };
}

export type ClockTool = '/loop' | '/schedule' | 'nic';

export function clockTool(laptopOff: boolean, needsLocal: boolean): { tool: ClockTool; text: string } {
  if (laptopOff && needsLocal) {
    return { tool: 'nic', text: 'Sprzeczność: chmura nie widzi niezacommitowanych plików, a /loop nie działa bez Twojej sesji. Zrób commit i push albo zostaw komputer włączony.' };
  }
  if (laptopOff) {
    return { tool: '/schedule', text: 'Zadanie w chmurze na świeżym klonie z GitHuba. Logowanie kontem claude.ai, zmiany na gałęziach claude/, najpierw reguła chroniąca main.' };
  }
  return { tool: '/loop', text: 'Powtórzenia w otwartej sesji. Każde wysyła całą rozmowę, więc nie zostawiaj pętli w długiej sesji. Zatrzymasz ją prośbą o anulowanie.' };
}

const TABLICE = 'lib/boards.ts\napp/api/boards/[id]/collaborators/route.ts\ncomponents/InviteDialog.tsx\napp/boards/[id]/page.tsx';
const LUPA = 'lib/visualSearch.ts\napp/api/visual-search/route.ts\ncomponents/CameraSearch.tsx';

export const PRESETS: Record<string, { a: Task; b: Task; dependent: boolean }> = {
  'Zaproszenia i lupa': {
    a: { name: 'tablice', files: TABLICE, migration: false, packages: false },
    b: { name: 'wyszukiwanie', files: LUPA, migration: false, packages: false },
    dependent: false,
  },
  'Błąd agenta: wspólny typ': {
    a: { name: 'tablice', files: TABLICE + '\nlib/types.ts\napp/layout.tsx', migration: false, packages: false },
    b: { name: 'wyszukiwanie', files: LUPA + '\nlib/types.ts', migration: false, packages: false },
    dependent: false,
  },
  'Dwie migracje': {
    a: { name: 'tablice', files: TABLICE + '\nprisma/schema.prisma', migration: true, packages: false },
    b: { name: 'ulubione', files: 'lib/favorites.ts\napp/api/favorites/route.ts\nprisma/schema.prisma', migration: true, packages: false },
    dependent: false,
  },
  'Zadanie zależne': {
    a: { name: 'tablice', files: TABLICE, migration: false, packages: false },
    b: { name: 'powiadomienia', files: 'lib/notifications.ts\ncomponents/InviteBadge.tsx', migration: false, packages: false },
    dependent: true,
  },
};

const LEVEL_CLASS: Record<Level, string> = {
  ok: 'text-emerald-400',
  warn: 'text-amber-400',
  error: 'text-rose-400',
};

function TaskForm(props: { title: string; task: Task; onChange: (t: Task) => void }) {
  const t = props.task;
  return (
    <fieldset className="space-y-2 rounded border border-slate-700 p-3">
      <legend className="px-1 font-semibold">{props.title}</legend>
      <label className="block text-sm">
        Nazwa (końcówka gałęzi)
        <input className="mt-1 w-full rounded bg-slate-900 p-1 font-mono" value={t.name} onChange={(e) => props.onChange({ ...t, name: e.target.value })} />
      </label>
      <label className="block text-sm">
        Pliki, jeden w linii (folder kończy się na /)
        <textarea className="mt-1 h-28 w-full rounded bg-slate-900 p-2 font-mono text-xs" value={t.files} onChange={(e) => props.onChange({ ...t, files: e.target.value })} />
      </label>
      <label className="flex items-center gap-2 text-sm">
        <input type="checkbox" checked={t.migration} onChange={(e) => props.onChange({ ...t, migration: e.target.checked })} />
        migracja bazy
      </label>
      <label className="flex items-center gap-2 text-sm">
        <input type="checkbox" checked={t.packages} onChange={(e) => props.onChange({ ...t, packages: e.target.checked })} />
        nowa paczka npm
      </label>
    </fieldset>
  );
}

export default function App() {
  const start = PRESETS['Zaproszenia i lupa'];
  const [a, setA] = useState<Task>(start.a);
  const [b, setB] = useState<Task>(start.b);
  const [dependent, setDependent] = useState(start.dependent);
  const [laptopOff, setLaptopOff] = useState(false);
  const [needsLocal, setNeedsLocal] = useState(true);
  const verdict = check(a, b, dependent);
  const clock = clockTool(laptopOff, needsLocal);

  return (
    <div className="min-h-screen space-y-4 bg-slate-950 p-4 text-slate-100">
      <h1 className="text-xl font-bold">Szalupy czy kolejka?</h1>
      <div className="flex flex-wrap gap-2 text-sm">
        {Object.keys(PRESETS).map((name) => (
          <button
            key={name}
            type="button"
            className="rounded bg-slate-800 px-2 py-1 hover:bg-slate-700"
            onClick={() => {
              setA(PRESETS[name].a);
              setB(PRESETS[name].b);
              setDependent(PRESETS[name].dependent);
            }}
          >
            {name}
          </button>
        ))}
      </div>
      <div className="grid gap-3 md:grid-cols-2">
        <TaskForm title="Zadanie A" task={a} onChange={setA} />
        <TaskForm title="Zadanie B" task={b} onChange={setB} />
      </div>
      <label className="flex items-center gap-2 text-sm">
        <input type="checkbox" checked={dependent} onChange={(e) => setDependent(e.target.checked)} />
        B potrzebuje wyniku A
      </label>
      <p role="status" className={'text-lg font-semibold ' + (verdict.parallel ? 'text-emerald-400' : 'text-rose-400')}>
        {verdict.parallel ? 'Równolegle: dwa worktree' : 'Po kolei: jedna sesja'}
      </p>
      <ul className="space-y-1 text-sm">
        {verdict.findings.map((f) => (
          <li key={f.text} className={LEVEL_CLASS[f.level]}>{f.level}: {f.text}</li>
        ))}
      </ul>
      <pre className="overflow-x-auto whitespace-pre-wrap rounded bg-slate-900 p-2 font-mono text-xs">{verdict.commands.join('\n')}</pre>
      <section className="space-y-2 rounded border border-slate-700 p-3">
        <h2 className="font-semibold">Kto pilnuje zegara</h2>
        <label className="flex items-center gap-2 text-sm">
          <input type="checkbox" checked={laptopOff} onChange={(e) => setLaptopOff(e.target.checked)} />
          ma działać, gdy laptop jest zamknięty
        </label>
        <label className="flex items-center gap-2 text-sm">
          <input type="checkbox" checked={needsLocal} onChange={(e) => setNeedsLocal(e.target.checked)} />
          potrzebuje niezacommitowanych plików z mojego katalogu
        </label>
        <p className="text-sm">
          <strong className="font-mono">{clock.tool}</strong>: {clock.text}
        </p>
      </section>
    </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 daje uruchomienie claude -w tablice w projekcie Treasure Map?

  2. 2. Co noc ma powstawać raport z otwartych zadań w repozytorium Treasure Map na GitHubie, także gdy laptop jest zamknięty. Czego użyjesz?

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

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż komendę, która po scaleniu i odblokowaniu usuwa worktree tablice:

  • Klikanie w kolejności

    Kliknij elementy w kolejności, aby zlecić jedną dużą, mechaniczną zmianę w wielu plikach, z każdą częścią we własnym worktree:

  1. PytanieQuiz: Co daje claude -w
  2. Ułóż w kolejnościSortowanie: Usunięcie worktree po rejsie
  3. PytanieQuiz: /loop czy /schedule
  4. Kliknij w kolejnościSekwencja: Duża zmiana w wielu plikach
  5. PytanieQuiz: Kiedy nie pracować równolegle

Przydatne artykuły