Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

archdeck

/archdeck

Tworzy animowane slajdy wyjaśniające problemy techniczne do filmów programistycznych, z jednolitymi danymi na każdej scenie.

Repozytorium
skillhub ↗
Licencja
MIT
Ostatnia zmiana repozytorium
31.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
10
Skrypty
2
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 31.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 2 skrypty w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: assets/deck.js, scripts/build.py

Co robi i kiedy

Tworzy animowane slajdy wyjaśniające problemy techniczne do filmów programistycznych, z jednolitymi danymi na każdej scenie.

Oryginalny opis (EN)

Animated explainer slides for programming videos — turns one technical problem (backend, database, system design, frontend, infra) into a deck of 1920×1080 HTML scenes that teach the mechanism: requests travel, scans crawl, races interleave, the bottleneck lights up. Picks a story arc, drafts a storyboard with one shared fact sheet (same data, consistent numbers on every slide) for your approval, then renders standalone per-slide HTML plus one single-file deck with step-by-step reveals, speaker notes, and a clean recording mode, to out/archdeck/<slug>/. No codebase needed. Use for "make slides

Jak działa

  1. Step 0 — Brief
  2. Step 1 — Get the mechanism right
  3. Step 2 — Pick the arc
  4. Step 3 — Storyboard → approval gate
  5. Step 4 — Render
  6. Step 5 — Build and lint
  7. Step 6 — Look at it
  8. Edit mode
Sekcje z nagłówków SKILL.md, w oryginale · 140 linii, 1 039 słów
Podgląd SKILL.md
---
name: archdeck
description: >-
  Animated explainer slides for programming videos — turns one technical
  problem (backend, database, system design, frontend, infra) into a deck of
  1920×1080 HTML scenes that teach the mechanism: requests travel, scans
  crawl, races interleave, the bottleneck lights up. Picks a story arc,
  drafts a storyboard with one shared fact sheet (same data, consistent
  numbers on every slide) for your approval, then renders standalone
  per-slide HTML plus one single-file deck with step-by-step
  reveals, speaker notes, and a clean recording mode, to
  out/archdeck/<slug>/. No codebase needed. Use for "make slides explaining X
  for my video", "animated architecture slides for a tutorial", "turn this
  system design problem into a presentation" — e.g. "/archdeck keyset vs
  offset pagination". For docs and mermaid diagrams of a real codebase use
  blueprint; to be taught a topic interactively use learn.
---

# archdeck — architecture explained in scenes

`/archdeck <problem>` — new deck from a problem statement
`/archdeck <slug> edit <what to change>` — revise storyboard + affected slides, rebuild
`/archdeck <slug> build` — re-lint and rebuild `index.html` after hand edits

Answer one question: **what sequence of pictures makes a viewer *see* why
this design works — and where it stops working?** The failure mode of
generated tech slides is a bullet list with boxes: topics as titles, every
idea on screen at once, numbers that change between slides, motion as
decoration. The countermeasures are structural: a story arc chosen first, a
fact sheet every number comes from, one claim and one focal point per
slide, and steps that follow causality.

## Step 0 — Brief

Get the date with `date +%F`. Derive a short kebab-case `<slug>` from the
problem. If `out/archdeck/<slug>/` exists, read its `storyboard.md` and
resume (or run the requested `edit`/`build`) instead of starting over.

Infer from the request, defaulting sensibly:

- **Language** — the language the user wrote in (badges and copy follow it).
- **Audience** — mid-level developer unless stated.
- **Length** — 10–14 slides (~1 min each) unless stated.
- **Voices** — narrator only; a two-voice dialogue (learner `S`, presenter
  `J`) when the problem has a "why are we doing this" pivot.
- **Theme** — drafting paper (light, most legible after video compression);
  blueprint (dark) on request.

Ask at most one round of questions, and only for what would change the arc:
the scenario if the problem is too abstract to make concrete ("caching" →
caching *what*, for *whom*?), or the takeaway if the user clearly has one in
mind. Otherwise proceed and state your assumptions in the storyboard.

## Step 1 — Get the mechanism right

There is no codebase; correctness comes from you. Work out the mechanism
end to end before any slide: what reads what, in what order, at what cost.

Build the **fact sheet** (format in `references/storyboard-template.md`): one
concrete scenario, realistic scale with the arithmetic shown, sample
entities reused on every mock, and the engine/version for any behavior that
varies (InnoDB vs Postgres, HTTP/1.1 vs 2, React 18 vs 19). If web search is
available, verify version-specific claims and defaults; if not, mark them
under "Claims to double-check" so the user can verify before recording.
Wrong numbers in a tutorial are worse than none.

## Step 2 — Pick the arc

Read `references/narrative-arcs.md`. Choose one arc, then write the brief:
misconception, aha, decision rule. Map beats to slides. The arc is where
"better than a list of slides" happens — a pivot, predict-pauses every 3–4
slides, a side quest that comes back, an ending that says *when* to use
what.

## Step 3 — Storyboard → approval gate

Write `out/archdeck/<slug>/storyboard.md` per
`references/storyboard-template.md`: per slide the claim-title, archetype,
concrete on-screen content, numbered steps with their motion, focal point,
bottom line, narration per step, and the bridge to the next slide. Choose
archetypes from `references/archetypes.md` — at least five different ones
per deck.

Show the brief and the one-row-per-slide table in chat and **wait for a
yes**. Apply requested changes to the file and re-show only what changed.
Rewriting a storyboard line costs seconds; re-rendering a slide costs
minutes. If the user said not to ask ("just make it"), note that and go on.

## Step 4 — Render

Read `references/visual-language.md`, `references/archetypes.md`, and
`references/animations.md`. Then:

1. Copy this skill's `assets/deck.css` and `assets/deck.js` into
   `out/archdeck/<slug>/assets/` (reuse the copies already there on an edit —
   the user may have tuned them).
2. For each slide write `out/archdeck/<slug>/slides/NN-<slide-slug>.html`
   starting from this skill's `assets/slide-template.html`: same `lang`,
   `data-theme` and deck `data-title` in every file; the archetype markup;
   `data-step` reveals exactly as storyboarded; narration in `.notes` with
   matching `data-step`s.
3. Rules that keep slides honest:
   - Every name and number comes from the fact sheet.
   - Only `deck.css` classes and tokens — inline style only for coordinates
     and motion knobs (`--x`, `--y`, `--at`, `--v`, `--d`, `--t`…). New
     visual needs go into a `<style>` block scoped by `[data-slug="…"]`.
   - Diagrams: explicit px size, matching SVG `viewBox`, shared arrowheads
     (`url(#ad-arrow)`, `-problem`, `-fix`…) — no per-slide `<defs>`, and
     any `id` prefixed with the slide number.
   - Code and queries are valid for the named dialect/version.
   - Nothing loads from the network except the Google Fonts that
     `deck.css` already imports — no CDNs, remote images, or scripts.

## Step 5 — Build and lint

```bash
python3 <this skill>/scripts/build.py out/archdeck/<slug>
```

It lints every slide (one section, a title, contiguous steps, narration per
step, no external resources, no duplicate ids, word budget), stamps each
slide's sheet number for its title block, then writes `index.html` (all
slides, CSS and JS inlined) and `notes.md` (the narration script, per
slide and step). Fix every ERROR and re-run; fix WARNs unless
the slide genuinely needs the words. Use `python` if `python3` isn't on
PATH.

## Step 6 — Look at it

Text that fits in your head can still overflow at 1920×1080. If a browser
tool is available, open `index.html#/N/99` (slide N at its last step) at a
1920×1080 viewport for every slide, screenshot, and fix overflow, overlap,
misaligned wires, and unreadable contrast; `window.archdeck.go(i, step)`
drives it too. Check step 0 of busy slides as well — the opening frame
must not give away the answer. If no browser is available, say the deck
was not visually checked.

Report in chat: the slide table (number · title · steps), the paths
(`index.html`, `slides/`, `notes.md`, `storyboard.md`), the claims still
marked to double-check, a reminder to open the deck once online before
recording (fonts load from Google Fonts and are cached after that), and the
controls:

```
→ / Space  next step     ← previous      ↓ ↑  next/prev slide    12⏎  jump
R replay step   F fullscreen   N notes   C clean (recording) mode   T theme
index.html?clean → record without HUD   #/5/2 → slide 5, step 2
```

## Edit mode

`/archdeck <slug> edit …`: change `storyboard.md` first, show the diff of
affected rows, then re-render only those slide files and rebuild. If the
fact sheet changes, find every slide that uses the changed value
(`grep` the old value in `slides/`) and update them all — a number that
changes on one slide but not the next is the bug viewers notice first.
Pliki w paczce (10)
  • SKILL.md 8 KB
  • assets/deck.css 40 KB
  • assets/deck.js 9 KB
  • assets/slide-template.html 1 KB
  • references/animations.md 5 KB
  • references/archetypes.md 17 KB
  • references/narrative-arcs.md 6 KB
  • references/storyboard-template.md 3 KB
  • references/visual-language.md 6 KB
  • scripts/build.py 8 KB

Wersje

W bazie nie ma innych skilli o nazwie archdeck.

Migawka bazy z 13.11.2026 · wersja paczki b82587644c7e (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100create-slide
    Tworzy nowe slajdy i prezentacje w repozytorium open-slide, z notatkami mówcy, w katalogu slides.
  • 100create-slide
    Tworzy nowe slajdy i prezentacje w repozytorium open-slide, z notatkami mówcy, w katalogu slides.
  • 100slide-deck
    Tworzy prezentację jako jeden plik HTML z animacjami, krokowym odsłanianiem treści i stylem do wydruku PDF.
  • 100deck
    Buduje prezentację w jednym pliku HTML: slajdy 1920×1080, nawigację klawiaturą, notatki prelegenta i druk do PDF, bez kroku budowania.
  • 100slide-deck
    Generuje dopracowaną, gotową do prezentacji stronę HTML z pokazem slajdów z tematu, dokumentu lub notatek.
  • 100claude-slides
    Tworzy i poprawia prezentacje w formacie Slides jako lokalne pliki i otwiera je w edytorze z eksportem do PDF, HTML lub PowerPoint.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.