Kurs vibe coding z Claude Code · Moduł 5: Klon Reddita

Rada załogi głosuje: najpierw test, potem kod

12 min czytania ·
W tej lekcji15

Ahoj! Na pokładzie trwa spór: płynąć na Tortugę czy na północ, po złoto z wraku. W tej lokacji budujesz Crew Council, pirackie forum w stylu Reddita, na którym załoga głosuje za pomysłami i przeciw nim, a najlepsze same wypływają na górę. Zasady głosowania łatwo złamać po cichu, dlatego Claude Code najpierw napisze sprawdzian, a dopiero potem kod, który go zaliczy.

Czego się nauczysz

  • poprosić Claude Code o konfigurację testów według dokumentacji Next.js i sprawdzić w Cursorze, co dodał;
  • zamówić najpierw testy, zobaczyć ich porażkę, a dopiero potem kod, który je przechodzi;
  • żądać dowodu: komendy i jej wyniku zamiast zdania "testy przechodzą";
  • rozpoznać agenta, który poprawia test zamiast kodu;
  • trzymać głosy w stanie listy, żeby sortowanie je widziało.

Nowy port: projekt crew-council

Forum to osobna aplikacja, więc dostaje własny projekt. Zakładasz go poleceniem z lekcji 1_2, zmieniając tylko nazwę. Zanim klikniesz Yes, porównaj komendę z tą:

npx create-next-app@latest crew-council --ts --eslint --tailwind --app --no-src-dir --no-cache-components --agents-md --no-agent-feedback --use-npm

Dalej znana pętla: sesja w folderze crew-council, npm run build jako dowód, krótki CLAUDE.md z importem @AGENTS.md jak w lekcji 1_7 i pierwszy commit.

Problem: zasady, które łatwo złamać

Głos pirata ma trzy stany: za ("up"), przeciw ("down") albo brak (null). Score posta to głosy za minus głosy przeciw. Zasady rady są takie:

  • plus albo minus bez wcześniejszego głosu dodaje jeden głos;
  • drugi klik w ten sam przycisk cofa głos;
  • zmiana z plusa na minus zdejmuje głos za i dodaje głos przeciw, więc score spada o 2, a w drugą stronę rośnie o 2.

To sześć przejść i każde da się zepsuć tak, że strona wygląda dobrze. Klikając, sprawdzisz dwa albo trzy, a test sprawdzi wszystkie w ułamku sekundy.

Test w jednym akapicie

Test to mały program, który wywołuje Twój kod z ustalonymi danymi i porównuje wynik z oczekiwanym, jak umowa: "post ma 10 głosów za, po kliknięciu plusa ma mieć 11". Narzędzie do testów uruchamia wszystkie umowy i melduje, które przeszły, a Claude może je uruchomić sam. Oficjalne dobre praktyki Claude Code radzą dać mu coś, co odpowiada "zalicza" albo "nie zalicza", i zawsze prosić o dowód: komendę i jej wynik.

Polecenie dla Claude Code: konfiguracja testów

Dokumentacja Next.js opisuje cztery narzędzia: Jest i Vitest do testów jednostkowych, Cypress i Playwright do testów całych ścieżek w przeglądarce. Wybieramy Vitest, bo według tej dokumentacji wystarczy mu jeden krótki plik konfiguracji, a Jest potrzebuje jeszcze kreatora npm init jest, paczki ts-node i ręcznego mapowania skrótu @/.

Polecenie dla Claude Code:

Skonfiguruj w Crew Council testy jednostkowe z Vitest zgodnie z dokumentacją
Next.js (node_modules/next/dist/docs/01-app/02-guides/testing/vitest.md):
paczki, vitest.config.mts i skrypt "test" w @package.json. Nie dodawaj
przykładowych testów. Jeśli npm zgłosi konflikt wersji, pokaż mi błąd
i zaproponuj poprawkę, zanim użyjesz --force albo --legacy-peer-deps.
Na koniec uruchom npm run test -- --run i pokaż wynik.

To dokumentacja, którą kreator zostawił w projekcie, zgodna z Twoją wersją Next.js.

Co zrobił Claude: konflikt wersji

Instalacja według dokumentacji zatrzymała się na błędzie. Oto jego najważniejsze linie:

npm error code ERESOLVE
npm error While resolving: vitest@5.1.0
npm error Found: @types/node@20.19.43
npm error peerOptional @types/node@"^22.0.0 || >=24.0.0" from vitest@5.1.0
npm error Fix the upstream dependency conflict, or retry this command with --force or --legacy-peer-deps to accept an incorrect (and potentially broken) dependency resolution.

ERESOLVE znaczy, że npm nie umie dobrać wersji, które do siebie pasują. Vitest 5 oczekuje typów Node.js w wersji co najmniej 22, a kreator wpisał do projektu @types/node w wersji 20 (stan na listopad 2026). Ostatnia linia kusi skrótem: --force i --legacy-peer-deps każą zignorować konflikt i zainstalować zależności "potencjalnie zepsute". Właściwa poprawka to typy zgodne z Twoim Node.js (sprawdzisz go przez node -v): przy linii 26 Claude proponuje npm install -D @types/node@26. Po niej instalacja przeszła bez błędów.

Co zrobił Claude: konfiguracja

Otwórz w Cursorze panel Source Control i kliknij package.json. W devDependencies przybyło pięć paczek: vitest, czyli samo narzędzie, @vitejs/plugin-react, które rozumie JSX, jsdom, czyli udawana przeglądarka, oraz @testing-library/react i @testing-library/dom do testów komponentów. W scripts doszła linia "test": "vitest". Teraz otwórz vitest.config.mts:

import { defineConfig } from "vitest/config";
import react from "@vitejs/plugin-react";

export default defineConfig({
  plugins: [react()],
  resolve: {
    tsconfigPaths: true,
  },
  test: {
    environment: "jsdom",
  },
});

environment: "jsdom" włącza udawaną przeglądarkę. resolve.tsconfigPaths uczy Vitest skrótu @/ z tsconfig.json, więc test importuje @/lib/votes jak reszta projektu. Dokumentacja Next.js robi to paczką vite-tsconfig-paths, ale przy pierwszym uruchomieniu Vite wypisał ostrzeżenie, że umie to sam, i podał tę opcję. Claude zamienił wtyczkę na opcję i odinstalował paczkę. Ostrzeżenie to nie błąd, ale zawsze je czytaj, bo często mówi, jak zrobić coś prościej.

Bez testów komenda kończy się napisem No test files found, exiting with code 1: narzędzie działa i czeka na pliki .test.ts, a pierwszy powstanie za chwilę.

Komenda testów w CLAUDE.md

npm run test w Twoim terminalu startuje w trybie obserwacji: testy ruszają po każdej zmianie pliku, a komenda trwa do Ctrl+C. Poproś więc: "Dopisz do CLAUDE.md komendę testów, jeden przebieg". W sekcji z komendami pojawia się linia:

- Testy: npm run test -- --run (Vitest, jeden przebieg bez trybu obserwacji)

Dwa myślniki przekazują resztę komendy do Vitest, a --run wyłącza obserwację.

Polecenie dla Claude Code: najpierw testy

Teraz zasady rady zamieniasz w sprawdzian. Kolejność jest celowa: testy powstają przed kodem, więc opisują Twoje zasady, a nie to, co akurat wyszło z kodu.

Crew Council: post ma upvotes, downvotes i userVote ('up', 'down' albo
null). Zdefiniuj typ Post i przykładowe posty w lib/posts.ts. Napisz
najpierw testy funkcji applyVote(post, clicked) w lib/votes.test.ts:
plus, minus, drugi klik cofa głos, zmiana z plusa na minus i z minusa
na plus (score zmienia się o 2), a przekazany post zostaje bez zmian.
W lib/votes.ts zostaw pusty szkielet funkcji. Uruchom testy: mają nie
przejść. Pokaż komendę i wynik, a potem zatrzymaj się przed kodem.

"Zatrzymaj się" daje Ci czas na przeczytanie testów, zanim Claude dopasuje do nich kod. Pusty szkielet sprawia, że testy padną na porównaniu wyników, a nie na brakującym pliku.

Co napisał Claude: test

Otwórz w Cursorze lib/votes.test.ts i przeczytaj go przed kodem. Typ Post z lib/posts.ts ma tytuł, treść, autora, społeczność, datę jako tekst ISO i trzy pola głosów. Na górze testu stoi post, na którym pracują wszystkie przypadki: 10 głosów za, 2 przeciw, userVote: null. Pierwszy przypadek:

it("plus bez wcześniejszego głosu dodaje głos za", () => {
  expect(applyVote(post, "up")).toMatchObject({ upvotes: 11, downvotes: 2, userVote: "up" });
});

it opisuje jeden przypadek zdaniem, a expect porównuje wynik z oczekiwanym. toMatchObject sprawdza tylko wymienione pola: 11 za, 2 przeciw, głos za. Wszystkie przypadki stoją w bloku describe("applyVote", ...), który grupuje testy jednej funkcji. Tak wygląda zmiana zdania:

it("zmiana z minusa na plus podnosi score o 2", () => {
  const voted = { ...post, downvotes: 3, userVote: "down" as const };
  const after = applyVote(voted, "up");
  expect(after).toMatchObject({ upvotes: 11, downvotes: 2, userVote: "up" });
  expect(score(after)).toBe(score(voted) + 2);
});

voted to ten sam post po głosie przeciw, a as const mówi TypeScriptowi, że "down" to dokładnie ta wartość, a nie dowolny tekst. Liczby w oczekiwaniach pochodzą z zasad rady i są wpisane ręcznie, a nie wyliczone tym samym wzorem co funkcja. Plik ma siedem przypadków: sześć przejść i jeden, który sprawdza, że oryginalny post się nie zmienił.

Czerwony: testy nie przechodzą

Claude uruchomił komendę z CLAUDE.md i pokazał wynik. Oto jego środek, bez nagłówka i bez szczegółów każdej porażki, które Vitest wypisuje niżej:

 ❯ lib/votes.test.ts (7 tests | 6 failed) 5ms
   ❯ applyVote (7)
     × plus bez wcześniejszego głosu dodaje głos za 3ms
     × minus bez wcześniejszego głosu dodaje głos przeciw 0ms
     × drugi klik w plus cofa głos 0ms
     × drugi klik w minus cofa głos 0ms
     × zmiana z plusa na minus obniża score o 2 0ms
     × zmiana z minusa na plus podnosi score o 2 0ms

      Tests  6 failed | 1 passed (7)

Sześć porażek to dobra wiadomość: każdy z tych testów naprawdę coś sprawdza. Siódmy przeszedł, bo pusty szkielet zwraca post bez zmian; test zasady, który przechodzi na pustym szkielecie, nie pilnowałby niczego. W szczegółach porażki oczekiwane pola mają znak minus, a otrzymane plus.

Zielony: funkcja według testów

Teraz prośba: "Napisz applyVote tak, żeby testy przeszły. Testów nie zmieniaj. Pokaż komendę i wynik". Otwórz lib/votes.ts:

export function applyVote(post: Post, clicked: "up" | "down"): Post {
  const nextVote: Vote = post.userVote === clicked ? null : clicked;

  const upvotes = post.upvotes - countSide(post.userVote, "up") + countSide(nextVote, "up");
  const downvotes =
    post.downvotes - countSide(post.userVote, "down") + countSide(nextVote, "down");

  return { ...post, upvotes, downvotes, userVote: nextVote };
}

Pierwsza linia ustala nowy głos: ten sam przycisk drugi raz daje null, inny daje kliknięty. Potem liczniki zdejmują stary głos i dodają nowy. countSide to mała funkcja z tego pliku, która zwraca 1, gdy głos stoi po danej stronie, a inaczej 0. Ostatnia linia buduje nowy obiekt ze spreadem, więc przekazany post zostaje nietknięty. Obok stoi score(post), czyli post.upvotes - post.downvotes. Wynik ponownego uruchomienia:

 Test Files  1 passed (1)
      Tests  7 passed (7)

To jest dowód: komenda i jej wynik, a nie zdanie "powinno działać".

Przegląd kapitana

  1. Test poprawiony, żeby przeszedł. To najgroźniejszy błąd agenta przy testach. Sprawdziliśmy funkcję, która przy zmianie zdania dodaje nowy głos, ale nie zdejmuje starego: dwa testy padają. Agent, któremu zależy na zielonym wyniku, potrafi wtedy poprawić oczekiwanie zamiast kodu:
-  expect(after).toMatchObject({ upvotes: 11, downvotes: 2, userVote: "up" });
-  expect(score(after)).toBe(score(voted) + 2);
+  expect(after).toMatchObject({ upvotes: 11, downvotes: 3, userVote: "up" });
+  expect(score(after)).toBe(score(voted) + 1);

Testy znów są zielone, a rada liczy jednego pirata dwa razy. Dlatego po każdej turze zaglądaj do Source Control: zmiana w pliku .test.ts, o którą nie prosiłeś, to sygnał do zatrzymania. Dopisz do CLAUDE.md pułapkę: "Test, który nie przechodzi, naprawiasz w kodzie; oczekiwanych wartości nie zmieniasz bez mojej zgody". Z lekcji 1_7 wiesz, że to wskazówka, a nie zamek, więc diff czytasz i tak.

  1. Sześć przejść. Policz przypadki: z braku na plus i na minus, cofnięcie plusa i minusa, zmiana w obie strony. Brakujący przypadek to zasada, której nikt nie pilnuje.

  2. Test-lustro. Oczekiwanie przepisane z funkcji, na przykład expect(score(after)).toBe(after.upvotes - after.downvotes), przejdzie zawsze, nawet przy źle policzonych głosach.

  3. Uruchom sam. Wpisz w sesji ! npm run test -- --run, jak w lekcji 0_3.

Głosy w liście, nie w przycisku

Czas na ekran. Typowy pomysł agenta to przycisk z własnym useState dla liczników: liczba na przycisku się zmienia, ale lista postów o tym nie wie, więc sortowanie po score nie przesuwa posta. To lekcja 2_3 w nowym przebraniu: dane potrzebne w dwóch miejscach trzyma wspólny rodzic.

Zbuduj stronę główną Crew Council. components/Feed.tsx trzyma posty
w stanie i zmienia je przez applyVote z @lib/votes.ts.
components/VoteButtons.tsx nie ma własnego stanu: dostaje score,
userVote i funkcję onVote. Sortowanie hot, new i top zrób jako czystą
funkcję sortPosts w lib/sort.ts, najpierw z testami. Na koniec testy,
lint i build.

Zakaz stanu w VoteButtons to cała poprawka: przycisk mówi tylko, co kliknięto, a liczy ten, kto trzyma listę. Otwórz components/Feed.tsx. Sercem jest funkcja, która zmienia jeden post:

const [posts, setPosts] = useState(initialPosts);
const [sortMode, setSortMode] = useState<SortMode>("hot");

const handleVote = (postId: string, clicked: "up" | "down") => {
  setPosts((prev) =>
    prev.map((post) => (post.id === postId ? applyVote(post, clicked) : post)),
  );
};

const visiblePosts = sortPosts(posts, sortMode);

map podmienia tylko post o pasującym id. Kolejność nie ma własnego stanu: visiblePosts liczy się przy każdym renderze z aktualnych głosów. Przycisk ▲ w VoteButtons ma onClick={() => onVote("up")}, aria-label="Głos za" dla czytnika ekranu i aria-pressed, które mówi, czy głos jest oddany.

W lib/sort.ts stoją trzy tryby: new układa po dacie, top po score, a hot łączy jedno z drugim wzorem z kodu rankingu, który Reddit opublikował jako open source:

export function hotScore(post: Post): number {
  const s = score(post);
  const order = Math.log10(Math.max(Math.abs(s), 1));
  const seconds = Date.parse(post.createdAt) / 1000 - 1134028003;
  return Math.sign(s) * order + seconds / 45000;
}

Math.log10 liczy rząd wielkości score: 10 głosów daje 1, a 100 daje 2. 1134028003 to stała z kodu Reddita, chwila z grudnia 2005 roku w sekundach. Każde 45 000 sekund, czyli 12,5 godziny młodości, waży tyle co dziesięć razy więcej głosów. Wzór nie pyta o zegar, tylko o datę posta, więc jest czystą funkcją, którą da się przetestować. sortPosts sortuje kopię [...posts], bo sort zmienia tablicę, na której działa.

Sprawdzian w przeglądarce: uruchom npm run dev, wybierz top i daj głos za drugiemu postowi. U nas dwa pierwsze miały remis 90 do 90, więc jeden głos przeniósł drugi na górę, a zmiana na minus zostawiła go z wynikiem 89.

Następny krok

Gdy testy, lint i build są zielone, poproś o commit, na przykład "Głosowanie: applyVote z testami, stan głosów w Feed". Potem kolejny mały krok w tej samej pętli:

Dodaj funkcję upvotePercent(post) w @lib/votes.ts: procent głosów za,
zaokrąglony do całości. Najpierw testy: 85 za i 15 przeciw daje 85,
brak głosów daje 0. Uruchom je przed kodem i po nim, pokaż oba wyniki.

Claude liczy Math.round(post.upvotes / (post.upvotes + post.downvotes) * 100) i najpierw sprawdza, czy suma nie wynosi zero, bo dzielenie przez zero dałoby NaN. W edytorze poniżej czeka feed z głosami w stanie listy i mały sprawdzian applyVote: zagłosuj i zobacz, jak post zmienia miejsce.

Pamiętaj: kapitan spisuje zasady rady, test pilnuje ich przy każdym głosowaniu, a kto poprawia test zamiast kodu, przestawia kompas, żeby pasował do kursu.

Kod do tej lekcji: App.jsx
// Crew Council: głosy żyją w stanie listy, przycisk tylko woła funkcję
import { useState } from 'react';

const startPosts = [
  { id: 'p1', title: 'Płyniemy na Tortugę czy na północ?', upvotes: 120, downvotes: 30, userVote: null, createdAt: '2026-11-13T08:00:00.000Z' },
  { id: 'p2', title: 'Mapa z krzyżykiem na Wyspie Czaszki', upvotes: 95, downvotes: 5, userVote: null, createdAt: '2026-11-14T06:00:00.000Z' },
  { id: 'p3', title: 'Jak załatać kadłub smołą?', upvotes: 40, downvotes: 2, userVote: null, createdAt: '2026-11-14T09:30:00.000Z' },
  { id: 'p4', title: 'Kraken zatopił nam szalupę', upvotes: 60, downvotes: 15, userVote: null, createdAt: '2026-11-12T18:00:00.000Z' },
];

const score = (post) => post.upvotes - post.downvotes;

// 1, gdy głos stoi po tej stronie; inaczej 0
const countSide = (vote, side) => (vote === side ? 1 : 0);

function applyVote(post, clicked) {
  const nextVote = post.userVote === clicked ? null : clicked;
  return {
    ...post,
    upvotes: post.upvotes - countSide(post.userVote, 'up') + countSide(nextVote, 'up'),
    downvotes: post.downvotes - countSide(post.userVote, 'down') + countSide(nextVote, 'down'),
    userVote: nextVote,
  };
}

// Wzór z kodu rankingu Reddita: rząd wielkości score plus wiek posta
function hotScore(post) {
  const s = score(post);
  const order = Math.log10(Math.max(Math.abs(s), 1));
  const seconds = Date.parse(post.createdAt) / 1000 - 1134028003;
  return Math.sign(s) * order + seconds / 45000;
}

function sortPosts(posts, mode) {
  const copy = [...posts];
  if (mode === 'new') return copy.sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt));
  if (mode === 'top') return copy.sort((a, b) => score(b) - score(a));
  return copy.sort((a, b) => hotScore(b) - hotScore(a));
}

// Mały sprawdzian: te same przypadki co w lib/votes.test.ts
const base = { upvotes: 10, downvotes: 2, userVote: null };
const checks = [
  { name: 'plus bez głosu', actual: applyVote(base, 'up'), expected: [11, 2, 'up'] },
  { name: 'minus bez głosu', actual: applyVote(base, 'down'), expected: [10, 3, 'down'] },
  { name: 'drugi klik w plus cofa głos', actual: applyVote({ ...base, upvotes: 11, userVote: 'up' }, 'up'), expected: [10, 2, null] },
  { name: 'drugi klik w minus cofa głos', actual: applyVote({ ...base, downvotes: 3, userVote: 'down' }, 'down'), expected: [10, 2, null] },
  { name: 'z plusa na minus: score -2', actual: applyVote({ ...base, upvotes: 11, userVote: 'up' }, 'down'), expected: [10, 3, 'down'] },
  { name: 'z minusa na plus: score +2', actual: applyVote({ ...base, downvotes: 3, userVote: 'down' }, 'up'), expected: [11, 2, 'up'] },
];
const passes = ({ actual, expected }) =>
  actual.upvotes === expected[0] && actual.downvotes === expected[1] && actual.userVote === expected[2];

function VoteButtons({ score, userVote, onVote }) {
  return (
    <div className="flex flex-col items-center gap-1">
      <button
        type="button"
        onClick={() => onVote('up')}
        aria-label="Głos za"
        aria-pressed={userVote === 'up'}
        className={userVote === 'up' ? 'text-orange-600' : 'text-gray-400 hover:text-orange-600'}
      >
        ▲
      </button>
      <span className="text-sm font-bold">{score}</span>
      <button
        type="button"
        onClick={() => onVote('down')}
        aria-label="Głos przeciw"
        aria-pressed={userVote === 'down'}
        className={userVote === 'down' ? 'text-blue-600' : 'text-gray-400 hover:text-blue-600'}
      >
        ▼
      </button>
    </div>
  );
}

export default function App() {
  const [posts, setPosts] = useState(startPosts);
  const [sortMode, setSortMode] = useState('top');

  const handleVote = (postId, clicked) => {
    setPosts((prev) => prev.map((post) => (post.id === postId ? applyVote(post, clicked) : post)));
  };

  const visiblePosts = sortPosts(posts, sortMode);

  return (
    <div className="min-h-screen bg-gray-100 p-4 text-gray-900">
      <div className="mx-auto max-w-xl space-y-3">
        <h1 className="text-2xl font-bold">Crew Council</h1>
        <div className="flex gap-2">
          {['hot', 'new', 'top'].map((mode) => (
            <button
              key={mode}
              type="button"
              onClick={() => setSortMode(mode)}
              aria-pressed={sortMode === mode}
              className={sortMode === mode ? 'rounded bg-orange-600 px-3 py-1 text-white' : 'rounded px-3 py-1 hover:bg-gray-200'}
            >
              {mode}
            </button>
          ))}
        </div>
        {visiblePosts.map((post) => (
          <article key={post.id} className="flex gap-3 rounded-lg border border-gray-200 bg-white p-3">
            <VoteButtons score={score(post)} userVote={post.userVote} onVote={(clicked) => handleVote(post.id, clicked)} />
            <h2 className="self-center font-semibold">{post.title}</h2>
          </article>
        ))}
        <section className="rounded-lg bg-white p-3 text-sm">
          <h2 className="mb-2 font-bold">Sprawdzian applyVote</h2>
          <ul className="space-y-1">
            {checks.map((check) => (
              <li key={check.name} className={passes(check) ? 'text-green-700' : 'font-semibold text-red-700'}>
                {passes(check) ? 'ZALICZONY' : 'NIEZALICZONY'}: {check.name}
              </li>
            ))}
          </ul>
          <p className="mt-2 text-gray-600">
            Zepsuj applyVote, na przykład usuń odejmowanie starego głosu, i zobacz, które przypadki zmienią kolor.
          </p>
        </section>
      </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. Jak oblicza się score w systemie voting?

  2. 2. Jakie wartości może mieć userVote?

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

Zadania praktyczne w grze

  • Edytor kodu

    Vote buttons component

  • Klikanie w kolejności

    Zbuduj obliczenie score klikając tokeny w kolejności:

  • Układanie w pionie

    Uporządkuj kroki pracy z Claude Code przy funkcji applyVote, tak jak w lekcji:

  • Edytor kodu

    Sort posts by mode

  • Układanie w poziomie

    Ułóż linię, która w applyVote ustala nowy głos (jedna linia, od lewej do prawej):

  • Układanie w poziomie

    Ułóż komendę z CLAUDE.md, która uruchamia testy jeden raz, bez trybu obserwacji (jedna linia, od lewej do prawej):

  • Klikanie w kolejności

    Zbuduj wyrażenie dające ujemny score (50 upvotes, 60 downvotes):

  1. PytanieQuiz: Score calculation
  2. PytanieQuiz: userVote state
  3. PytanieQuiz: Wynik score 100 vs 20
  4. Zadanie z kodemPraktyka: Vote buttons
  5. Kliknij w kolejnościSekwencja: Oblicz score
  6. PytanieQuiz: Toggle upvote
  7. Ułóż w kolejnościSortowanie: Najpierw test, potem kod
  8. PytanieQuiz: Wzór hot
  9. PytanieQuiz: Procent upvote
  10. Zadanie z kodemPraktyka: Sortowanie postów
  11. Ułóż w kolejnościSortowanie: Nowy głos w applyVote
  12. PytanieQuiz: Hot a wiek posta
  13. PytanieQuiz: Tryby top i new
  14. Ułóż w kolejnościSortowanie: Komenda testów
  15. Kliknij w kolejnościSekwencja: Negatywny score

Przydatne artykuły