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

Zasady załogi: CLAUDE.md dla zespołu, reguły ścieżek i ustawienia

8 min czytania
W tej lekcji9

Treasure Map rośnie a razem z nim CLAUDE.md. Po kilku tygodniach dopisywania ma ponad sto linii: połowa to opis katalogów, zasady dla tras API leżą między zasadami dla komponentów, a wczoraj Claude napisał trasę bez sprawdzenia sesji, choć ta zasada stała w linii 112. Do tego do projektu dołącza druga osoba i nie chcesz, żeby dostała Twoje notatki o lokalnej bazie. Jeden długi plik przestał być mapą, a stał się stertą pergaminów.

Co już umiesz

W lekcji 1_7 wygenerowałeś CLAUDE.md komendą /init, zaimportowałeś AGENTS.md linią @AGENTS.md i nauczyłeś się, że dalsza praca to głównie skreślanie. W lekcji 8_4 zamknąłeś .env regułą deny w .claude/settings.json, a w lekcji 10_5 dołożyłeś reguły ask dla wdrożeń. W lekcjach 14_1 i 14_2 pisałeś skrypty z claude -p. Teraz ten sam porządek ustawiasz dla załogi: kto czyta które zasady, kiedy i z czyjego pliku.

Cztery poziomy pamięci

Claude Code szuka plików z instrukcjami w czterech miejscach. Oto one, od najszerszego zasięgu do najwęższego:

/Library/Application Support/ClaudeCode/CLAUDE.md   # polityka organizacji (macOS), wgrywa ją dział IT
~/.claude/CLAUDE.md                                  # Ty, we wszystkich projektach
treasure-map/CLAUDE.md                               # cała załoga, w repozytorium
treasure-map/CLAUDE.local.md                         # Ty, tylko ten projekt, poza Gitem

Pliki się nie nadpisują, tylko sklejają w jeden tekst: szersze najpierw, a CLAUDE.local.md na końcu swojego poziomu. Gdy dwa pliki mówią co innego, Claude może wybrać dowolną wersję, więc spójności pilnujesz Ty. Polityki organizacji nie wyłączysz u siebie, ale w Treasure Map jej nie ma, bo dotyczy komputerów firmowych. CLAUDE.md w podkatalogu, na przykład app/api/CLAUDE.md, ładuje się dopiero wtedy, gdy Claude dotknie pliku w tym katalogu.

Polecenie dla Claude Code

Porządki zlecasz, a nie robisz ręcznie. W sesji w folderze treasure-map napisz:

Przejrzyj @CLAUDE.md. Usuń linie, które wyczytałbyś z kodu albo z package.json,
także opis katalogów. Zasady dla app/api przenieś do .claude/rules/api.md,
a dla components/ do .claude/rules/components.md, każdą z nagłówkiem paths.
Moje notatki o lokalnej bazie przenieś do CLAUDE.local.md i dopisz go do .gitignore.
Gotowe, gdy CLAUDE.md ma mniej niż 30 linii. Na koniec wypisz, co usunąłeś i dokąd przeniosłeś.

Polecenie nazywa trzy cele i podaje miarę końca, więc Claude wie, kiedy przestać, a Ty wiesz, co sprawdzić.

Co napisał Claude: krótki CLAUDE.md

Otwórz CLAUDE.md w Cursorze. U nas po porządkach został taki plik:

@AGENTS.md

# Komendy sprawdzające
- Jeden plik testów: `npm run test -- --run lib/pins.test.ts`
- Wszystkie testy: `npm run test -- --run`
- Typy: `npx tsc --noEmit`, lint: `npm run lint`

# Pułapki
- Baza z `npx prisma dev` startuje osobno; bez niej trasy w app/api zwracają 500.
- `getCurrentUserId()` z `lib/session.ts` to udawane logowanie z ciasteczka `demo-user`.

# Decyzje
- Migracji w `prisma/migrations/` nie edytujemy; zmiana schematu to nowa migracja.

Każda linia mówi coś, czego Claude nie zobaczy w kodzie: jak sprawdzić pracę, gdzie kod myli i co ustaliła załoga. Zniknęły opis katalogów i lista bibliotek, bo Claude i tak czyta repozytorium. Import @AGENTS.md został na górze, jak w lekcji 1_7. Pamiętaj tylko, że import porządkuje, ale nie odchudza: zaimportowany plik ładuje się razem z CLAUDE.md i zajmuje w kontekście tyle samo miejsca.

Co napisał Claude: reguły ze ścieżkami

Zasady dla części kodu trafiły do folderu .claude/rules/. Reguła to zwykły plik Markdown z frontmatterem, czyli ustawieniami między liniami ---, jak w skillu z lekcji 6_1:

---
paths:
  - "app/api/**/*.ts"
---

# Trasy API

- Każda trasa, która zmienia dane, najpierw woła `getCurrentUserId()`: brak sesji to 401, cudza tablica to 403.
- Dane wejściowe sprawdzaj schematem Zod z `lib/`, nigdy ręcznym `typeof`.
- Test trasy leży obok niej i mockuje `@/lib/session`.

paths to jedyne pole, które Claude Code czyta z reguły. Wzorzec liczy się od folderu projektu: ** znaczy dowolnie głęboko, a *.ts każdy plik TypeScript. Według dokumentacji taka reguła trafia do kontekstu dopiero wtedy, gdy Claude czyta, zapisuje albo edytuje pasujący plik, a reguła bez paths ładuje się na starcie, jak CLAUDE.md. Sprawdziliśmy to: Claude przeczytał app/api/boards/[id]/pins/route.ts, w kontekście pojawiła się api.md, a components.md nie. Od razu też zauważył, że ta trasa sprawdza pinId ręcznym typeof, wbrew drugiej zasadzie.

Notatki osobiste trafiły do CLAUDE.local.md, a do .gitignore doszła jedna linia z nazwą tego pliku:

CLAUDE.local.md

Claude czyta ten plik jak każdy inny CLAUDE.md, ale Git go nie widzi, więc Twoje notatki nie popłyną do załogi.

Przegląd kapitana

Otwórz diff CLAUDE.md w panelu Source Control i sprawdź:

  1. Test każdej linii. Czy Claude znalazłby to w kodzie? Jeśli tak, linia jest do skreślenia.
  2. Wzorzec trafia w pliki. app/api/**/*.ts pasuje do tras Treasure Map. Wzorzec src/app/api/** skopiowany z innego projektu nie pasuje do niczego, bo tu nie ma folderu src, a reguła po cichu nigdy się nie załaduje. Poproś Claude o przeczytanie jednej trasy i zapytaj, jakie zasady z .claude/rules ma teraz w kontekście.
  3. Plik prywatny jest prywatny. git check-ignore -v CLAUDE.local.md wypisze linię .gitignore, która go ukrywa. Pusta odpowiedź znaczy, że plik trafi do commita.

Typowy błąd agenta: "porządkując" plik, Claude dopisuje z powrotem sekcję w rodzaju # Struktura projektu z drzewem app/, lib/ i components/. Rozpoznasz ją w diffie po zielonym drzewie katalogów. Oficjalne dobre praktyki mówią wprost, że architektury i układu plików nie opisujesz, bo Claude czyta repozytorium sam. Do okresowego przeglądu służy /doctor prompt-audit: Claude szuka w CLAUDE.md, regułach, skillach i agentach instrukcji przestarzałych i sprzecznych, a niczego nie zmienia, dopóki o to nie poprosisz.

Ustawienia: kto ma ostatnie słowo

Pamięć mówi Claude, jak pracować, a ustawienia mówią Claude Code, na co mu pozwolić. Plików ustawień też jest kilka. Gdy ten sam klucz stoi w dwóch, wygrywa wyższy, licząc od najwyższego:

  1. ustawienia zarządzane organizacji;
  2. linia poleceń, czyli --settings przy starcie;
  3. .claude/settings.local.json: Ty, ten projekt;
  4. .claude/settings.json: załoga, w repozytorium;
  5. ~/.claude/settings.json: Ty, wszystkie projekty.

Listy, takie jak permissions.allow, nie nadpisują się, tylko łączą. Tak wygląda plik załogi w Treasure Map:

{
  "permissions": {
    "allow": ["Bash(npm run test *)", "Bash(npm run lint)", "Bash(npx tsc --noEmit)"],
    "ask": ["Bash(npx prisma migrate *)", "Bash(git push *)"],
    "deny": ["Read(./.env)", "Read(./.env.*)"]
  }
}

allow puszcza testy, lint i typy bez pytania, ask każe pytać o migracje i push, a deny z lekcji 8_4 zamyka sekrety. Dla każdego wywołania Claude Code sprawdza reguły w tej samej kolejności: najpierw deny, potem ask, na końcu allow, bez względu na plik, z którego pochodzą. Gdy żadna reguła nie pasuje, decyduje tryb uprawnień. Twoje allow dla git push w ustawieniach użytkownika nie przebije więc ask załogi, a deny z dowolnego pliku przebija każde allow. Swoje wyjątki trzymasz w pliku lokalnym:

{
  "permissions": {
    "allow": ["Bash(npx prisma studio)"]
  }
}

Tu Claude Code zapisuje też odpowiedź "Yes, and don't ask again" i przy pierwszym zapisie sam chroni ten plik przed commitem. Plik założony ręcznie dopisz do .gitignore sam. Jeszcze jedna zasada dla załogi: reguły allow z .claude/settings.json działają dopiero po zaakceptowaniu okna zaufania do folderu, a deny i ask od razu, bo tylko ograniczają. Nasz przebieg claude -p w folderze bez zaufania wypisał: Ignoring 3 permissions.allow entries from .claude/settings.json: this workspace has not been trusted.

Gdy reguła działa inaczej, niż myślisz, wpisz /permissions: ta komenda pokazuje każdą regułę razem z plikiem, z którego pochodzi. /status pokazuje tylko, które pliki ustawień się wczytały.

Skrypty z argumentami: $1 i "$*"

Zasady załogi przydają się też w skryptach z lekcji 14_2. Argument to słowo wpisane po nazwie skryptu: Bash wkłada pierwsze do $1, a wszystkie razem do "$*". Generator komponentów potrzebuje jednej nazwy:

NAME=$1
if [ -z "$NAME" ]; then
  echo "Podaj nazwę komponentu, np.: bash scripts/generate-component.sh BoardBadge"
  exit 1
fi

Po bash scripts/generate-component.sh BoardBadge zmienna NAME to BoardBadge, a bez argumentu skrypt kończy się, zanim zapłacisz za pusty przebieg. Dalej nazwa trafia do polecenia:

claude -p "Utwórz komponent React $NAME w TypeScript w components/$NAME.tsx i test Vitest w components/$NAME.test.tsx. Trzymaj się zasad z .claude/rules/components.md." \
  --model sonnet --allowedTools "Write" --max-turns 6

Dlaczego polecenie wskazuje regułę wprost? Reguła ze ścieżkami ładuje się przy odczycie, zapisie albo edycji pasującego pliku, a nowego komponentu nie ma, dopóki Claude go nie zapisze. --allowedTools "Write" zatwierdza zapis nowych plików, jak w lekcji 14_1. W zadaniu w edytorze dołożysz trzeci plik, .stories.tsx dla Storybooka, czyli narzędzia, które pokazuje komponenty w izolacji.

Wyszukiwarka kodu potrzebuje za to całego zdania, więc bierze wszystkie argumenty:

QUERY="$*"
claude -p "Znajdź w projekcie kod, który dotyczy: $QUERY. Odpowiedz listą: plik:linia i jedno zdanie, co tam się dzieje." \
  --model sonnet --tools "Read,Grep,Glob" --max-turns 6

Po bash scripts/ai-search.sh gdzie sprawdzamy właściciela tablicy skrypt z $1 przekazałby Claude samo "gdzie", a z "$*" całe zdanie. Cudzysłów to dobry nawyk: gdy $* bez cudzysłowu stoi w komendzie jako argument, Bash rozbija tekst na słowa, a gwiazdkę z pytania zamienia na listę plików. Na atrapie claude pytanie gdzie * sprawdzamy zamieniło się u nas w "gdzie AGENTS.md CLAUDE.local.md CLAUDE.md README.md app ...". Narzędzia Read,Grep,Glob wystarczą, bo w trybie -p Claude czyta bez pytania.

Następny krok

Dołóż trzecią regułę i od razu ją sprawdź:

Dodaj .claude/rules/testing.md z zasadami testów Vitest i paths na *.test.ts i *.test.tsx.
Potem przeczytaj lib/pins.test.ts i wypisz reguły z .claude/rules, które masz teraz w kontekście.

Poproś o commit, na przykład "Zasady załogi: krótki CLAUDE.md, reguły i ustawienia", i sprawdź w Source Control, że nie ma w nim CLAUDE.local.md ani .claude/settings.local.json. W edytorze obok wybierzesz plik z Treasure Map i zobaczysz, które pliki pamięci i reguły trafiają wtedy do kontekstu, a dla wybranej komendy, która reguła uprawnień o niej decyduje i z którego pliku pochodzi.

Pamiętaj: na mapie dla załogi zaznaczasz rafy, a nie każdą falę.

Kod do tej lekcji: App.tsx
// Mapa zasad załogi: które instrukcje widzi Claude przy danym pliku i która reguła decyduje o komendzie
import { useState } from 'react';

export interface MemoryFile {
  path: string;
  scope: string;
  paths?: string[];
}

export const MEMORY: MemoryFile[] = [
  { path: '~/.claude/CLAUDE.md', scope: 'Ty, wszystkie projekty' },
  { path: 'CLAUDE.md', scope: 'załoga, w repozytorium' },
  { path: 'CLAUDE.local.md', scope: 'Ty, ten projekt, poza Gitem' },
  { path: '.claude/rules/api.md', scope: 'reguła ze ścieżkami', paths: ['app/api/**/*.ts'] },
  { path: '.claude/rules/components.md', scope: 'reguła ze ścieżkami', paths: ['components/**/*.tsx'] },
  { path: '.claude/rules/testing.md', scope: 'reguła ze ścieżkami', paths: ['**/*.test.ts', '**/*.test.tsx'] },
];

export const FILES = [
  'app/api/pins/route.ts',
  'app/api/boards/[id]/pins/route.ts',
  'components/PinCard.tsx',
  'lib/pins.ts',
  'lib/pins.test.ts',
  'prisma/schema.prisma',
];

const SPECIAL = '.+?^$()[]{}|\\';

export function globToRegExp(glob: string): RegExp {
  let re = '';
  for (let i = 0; i < glob.length; i++) {
    const ch = glob[i];
    if (ch === '*' && glob[i + 1] === '*') {
      if (glob[i + 2] === '/') {
        re += '(?:.*/)?';
        i += 2;
      } else {
        re += '.*';
        i += 1;
      }
    } else if (ch === '*') {
      re += '[^/]*';
    } else if (SPECIAL.includes(ch)) {
      re += '\\' + ch;
    } else {
      re += ch;
    }
  }
  return new RegExp('^' + re + '$');
}

export interface Loaded {
  path: string;
  scope: string;
  status: 'start' | 'file' | 'no';
  note: string;
}

export function loadedFor(file: string, apiPattern: string): Loaded[] {
  return MEMORY.map((m) => {
    if (!m.paths) {
      return { path: m.path, scope: m.scope, status: 'start', note: 'ładuje się na starcie sesji' };
    }
    const patterns = m.path === '.claude/rules/api.md' ? [apiPattern] : m.paths;
    const hit = patterns.some((p) => globToRegExp(p).test(file));
    return hit
      ? { path: m.path, scope: m.scope, status: 'file', note: 'ładuje się, gdy Claude czyta, zapisuje albo edytuje ten plik (paths: ' + patterns.join(', ') + ')' }
      : { path: m.path, scope: m.scope, status: 'no', note: 'nie pasuje do ' + patterns.join(', ') };
  });
}

export type Decision = 'deny' | 'ask' | 'allow';

export interface Rule {
  decision: Decision;
  pattern: string;
  source: string;
}

export const RULES: Rule[] = [
  { decision: 'allow', pattern: 'Bash(git push *)', source: '~/.claude/settings.json' },
  { decision: 'allow', pattern: 'Bash(npm run test *)', source: '.claude/settings.json' },
  { decision: 'allow', pattern: 'Bash(npm run lint)', source: '.claude/settings.json' },
  { decision: 'ask', pattern: 'Bash(npx prisma migrate *)', source: '.claude/settings.json' },
  { decision: 'ask', pattern: 'Bash(git push *)', source: '.claude/settings.json' },
  { decision: 'deny', pattern: 'Read(./.env)', source: '.claude/settings.json' },
  { decision: 'allow', pattern: 'Bash(npx prisma studio)', source: '.claude/settings.local.json' },
];

export const COMMANDS = [
  'npm run test -- --run',
  'npm run lint',
  'npx prisma migrate dev',
  'git push origin main',
  'cat .env',
  'npx prisma studio',
  'npm install',
];

export function ruleMatches(pattern: string, command: string): boolean {
  const m = /^(\w+)\((.*)\)$/.exec(pattern);
  if (!m) return false;
  const tool = m[1];
  const arg = m[2];
  if (tool === 'Read') {
    const parts = command.split(' ');
    return parts[0] === 'cat' && parts[1] === arg.replace(/^\.\//, '');
  }
  if (arg.endsWith(' *')) {
    const prefix = arg.slice(0, -2);
    return command === prefix || command.startsWith(prefix + ' ');
  }
  return command === arg;
}

export interface Verdict {
  decision: Decision | 'mode';
  rule?: Rule;
  text: string;
}

export function decide(command: string, rules: Rule[], trusted: boolean): Verdict {
  const order: Decision[] = ['deny', 'ask', 'allow'];
  let skipped = false;
  for (const decision of order) {
    for (const r of rules) {
      if (r.decision !== decision || !ruleMatches(r.pattern, command)) continue;
      if (decision === 'allow' && !trusted && r.source === '.claude/settings.json') {
        skipped = true;
        continue;
      }
      const texts: Record<Decision, string> = {
        deny: 'Odmowa. deny sprawdzane jest pierwsze i wygrywa z każdym allow, z dowolnego pliku.',
        ask: 'Claude Code pyta o zgodę. ask stoi przed allow, więc czyjeś allow tego nie przebije.',
        allow: 'Bez pytania.',
      };
      return { decision, rule: r, text: texts[decision] };
    }
  }
  return {
    decision: 'mode',
    text: skipped
      ? 'Reguła allow z .claude/settings.json czeka na zaufanie do folderu, więc decyduje tryb uprawnień.'
      : 'Żadna reguła nie pasuje, więc decyduje tryb uprawnień.',
  };
}

const STATUS_CLASS: Record<Loaded['status'], string> = {
  start: 'text-sky-300',
  file: 'text-emerald-400',
  no: 'text-slate-500',
};

const DECISION_CLASS: Record<Verdict['decision'], string> = {
  deny: 'text-rose-400',
  ask: 'text-amber-400',
  allow: 'text-emerald-400',
  mode: 'text-slate-300',
};

export default function App() {
  const [file, setFile] = useState(FILES[1]);
  const [apiPattern, setApiPattern] = useState('app/api/**/*.ts');
  const [command, setCommand] = useState(COMMANDS[3]);
  const [trusted, setTrusted] = useState(true);
  const loaded = loadedFor(file, apiPattern);
  const verdict = decide(command, RULES, trusted);

  return (
    <div className="min-h-screen space-y-4 bg-slate-950 p-4 text-slate-100">
      <h1 className="text-xl font-bold">Zasady załogi w Treasure Map</h1>
      <section className="space-y-2">
        <h2 className="font-semibold">Pamięć i reguły przy pliku</h2>
        <label className="block text-sm">
          Claude pracuje z plikiem{' '}
          <select className="rounded bg-slate-800 p-1" value={file} onChange={(e) => setFile(e.target.value)}>
            {FILES.map((f) => (
              <option key={f} value={f}>{f}</option>
            ))}
          </select>
        </label>
        <label className="block text-sm">
          paths w .claude/rules/api.md{' '}
          <input className="rounded bg-slate-800 p-1 font-mono" value={apiPattern} onChange={(e) => setApiPattern(e.target.value)} />
        </label>
        <ul className="space-y-1 text-sm">
          {loaded.map((l) => (
            <li key={l.path} className="rounded border border-slate-800 p-2">
              <strong className={STATUS_CLASS[l.status]}>{l.path}</strong> ({l.scope}): {l.note}
            </li>
          ))}
        </ul>
      </section>
      <section className="space-y-2">
        <h2 className="font-semibold">Kto decyduje o komendzie</h2>
        <div className="flex flex-wrap items-center gap-3 text-sm">
          <select className="rounded bg-slate-800 p-1 font-mono" value={command} onChange={(e) => setCommand(e.target.value)}>
            {COMMANDS.map((c) => (
              <option key={c} value={c}>{c}</option>
            ))}
          </select>
          <label className="flex items-center gap-2">
            <input type="checkbox" checked={trusted} onChange={(e) => setTrusted(e.target.checked)} />
            zaakceptowałem okno zaufania do folderu
          </label>
        </div>
        <p role="status" className="rounded border border-slate-700 p-2 text-sm">
          <strong className={DECISION_CLASS[verdict.decision]}>{verdict.decision}</strong>{' '}
          {verdict.rule ? verdict.rule.pattern + ' z pliku ' + verdict.rule.source + '. ' : ''}
          {verdict.text}
        </p>
        <ul className="font-mono text-xs text-slate-400">
          {RULES.map((r, i) => (
            <li key={i}>{r.decision} {r.pattern} ({r.source})</li>
          ))}
        </ul>
      </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. Zasady dotyczą tylko tras w app/api Treasure Map. Gdzie je zapisać, żeby Claude miał je w kontekście tylko przy pracy z tymi plikami?

  2. 2. Którą linię warto usunąć z CLAUDE.md Treasure Map?

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

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż linie pliku .claude/rules/api.md od góry, tak jak w lekcji:

  • Układanie w pionie

    Ułóż części krótkiego CLAUDE.md Treasure Map od góry: najpierw import, potem jak sprawdzić pracę, potem pułapki, na końcu decyzje załogi:

  • Edytor kodu

    Napisz w commands.sh skrypt smart-commit.sh: weź diff ze staging area (git diff --cached), poproś claude -p o wiadomość w formacie Conventional Commits, pokaż ją, zapytaj o zgodę (read) i wykonaj git commit -m.

  • Układanie w pionie

    Uporządkuj pliki CLAUDE.md od najszerszego zasięgu do najwęższego, czyli w kolejności, w jakiej Claude Code skleja je w kontekście:

  • Edytor kodu

    Napisz w commands.sh skrypt generate-component.sh: nazwę komponentu weź z $1 i poproś claude -p o trzy pliki w src/components: <Nazwa>.tsx, <Nazwa>.test.tsx i <Nazwa>.stories.tsx (Storybook).

  • Układanie w pionie

    Ten sam klucz stoi w kilku plikach ustawień. Uporządkuj źródła od tego, które wygrywa, do tego, które przegrywa:

  • Edytor kodu

    Napisz w commands.sh skrypt ai-search.sh: zapytanie weź z argumentów skryptu ($1 albo "$*") i przekaż je do claude -p, żeby Claude sam znalazł pasujący kod i podał pliki oraz numery linii.

  • Układanie w pionie

    Uporządkuj, w jakiej kolejności Claude Code sprawdza reguły uprawnień dla jednego wywołania narzędzia:

  • Układanie w poziomie

    Ułóż regułę ask, która każe Claude Code pytać o zgodę przy każdej komendzie migracji Prismy:

  • Klikanie w kolejności

    Kliknij elementy w kolejności, aby sprawdzić, która linia .gitignore ukrywa Twoje prywatne notatki:

  • Klikanie w kolejności

    Kliknij elementy w kolejności, aby złożyć wzorzec paths, który pasuje do każdego pliku .ts w app/api, także w podfolderach:

  1. PytanieQuiz: Reguła dla tras API
  2. Ułóż w kolejnościSortowanie: Plik reguły ze ścieżkami
  3. Ułóż w kolejnościSortowanie: Części CLAUDE.md Treasure Map
  4. Zadanie z kodemPraktyka: Generator wiadomości commitów
  5. PytanieQuiz: Linia do skreślenia z CLAUDE.md
  6. Ułóż w kolejnościSortowanie: Poziomy pamięci od najszerszego
  7. Zadanie z kodemPraktyka: Generator komponentów
  8. PytanieQuiz: Prywatne notatki w projekcie
  9. PytanieQuiz: Import a rozmiar kontekstu
  10. Ułóż w kolejnościSortowanie: Pierwszeństwo plików ustawień
  11. Zadanie z kodemPraktyka: Wyszukiwarka kodu zwykłym zdaniem
  12. PytanieQuiz: Reguła ask a allow z innego pliku
  13. Ułóż w kolejnościSortowanie: Kolejność sprawdzania reguł
  14. Ułóż w kolejnościSortowanie: Reguła ask dla migracji
  15. PytanieQuiz: Osobista reguła w projekcie
  16. Kliknij w kolejnościSekwencja: Czy plik prywatny jest ukryty
  17. PytanieQuiz: Źródło reguły uprawnień
  18. PytanieQuiz: Reguły allow i zaufanie do folderu
  19. Kliknij w kolejnościSekwencja: Wzorzec paths dla tras
  20. PytanieQuiz: Kiedy ładuje się reguła ze ścieżkami
  21. PytanieQuiz: $1 a "$*" w skrypcie

Przydatne artykuły