Przejdź do treści
Biblioteka skilli
Projektowanie i UX · Planowanie

start

/start

Uruchamia lub wznawia projekt systemu projektowego w repozytorium: wykrywa stos, zadaje pytania i prowadzi dalsze kroki.

Repozytorium
massimo ↗
Licencja
MIT
Ostatnia zmiana repozytorium
10.11.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
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

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

Licencja

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

Co robi i kiedy

Uruchamia lub wznawia projekt systemu projektowego w repozytorium: wykrywa stos, zadaje pytania i prowadzi dalsze kroki.

Wyzwalacze z opisu

kick off design automationwhere are wecarry onnext step
Oryginalny opis (EN)

Start or resume massimo's design-system project in this repo. Use when the user wants to set up a design system, build or clean up tokens, components or stories, "kick off design automation", or continue design-system work from an earlier session ("where are we", "carry on", "next step"). On first run it detects the stack, asks a few short questions, and creates the in-repo project; on later runs it reads the project's status and routes to the next phase.

Jak działa

  1. Which path
  2. Kickoff
  3. Resume
  4. Rules
Sekcje z nagłówków SKILL.md, w oryginale · 52 linii, 1 702 słów
Podgląd SKILL.md
---
name: start
description: Start or resume massimo's design-system project in this repo. Use when the user wants to set up a design system, build or clean up tokens, components or stories, "kick off design automation", or continue design-system work from an earlier session ("where are we", "carry on", "next step"). On first run it detects the stack, asks a few short questions, and creates the in-repo project; on later runs it reads the project's status and routes to the next phase.
---

# massimo: start

Front door for everything massimo does in a repo. It sets the project up once, then on every later run reads where things stand and hands over to the right phase skill. A designer or developer should never need to remember which command comes next.

**Plugin root.** Two directories above this skill's base directory. Call it `<plugin>`; scripts are at `<plugin>/scripts/`. Read `<plugin>/reference/project.md` now: it is the contract for the project folder, phases and session protocol. `<project>` is the project folder: `projectDir` in `massimo.config.json`, `design-system` by default.

## Which path

Look for `massimo.config.json` in the folder Claude started in and each folder above it, up to the repo root (git toplevel). The nearest one is the project, and its folder is the project root: a monorepo can keep the project in one package.

A session started at the repo top does not see a project kept in a package, and neither does the session hook. In a monorepo with no config at the top, look for `massimo.config.json` in its packages before taking Kickoff; when one has it, take Resume and run the scripts from inside that package.

- **Absent** → Kickoff.
- **Present** → Resume.

## Kickoff

1. **Detect.** Run `node <plugin>/scripts/detect.mjs`. Summarise it in four or five plain lines: framework, styling, where components seem to live (with counts), the style files that hold tokens, existing story tools, Playwright yes/no, and, when it reports `adoptable`, what the repo already has for its design system. Then settle where the project lives. In a monorepo it is one of two places, and the `monorepo` flag alone does not tell which:
   - **The root, with globs into the packages**, when the design system spans packages: components, stories or tokens sit in more than one package, or the story tool's config (`.storybook/`, `.ladle/`) or the tokens sit at the root while the components live in packages, as in a repo with one package per component. Keep the root and point the config's globs into the packages, for example `packages/*/src/**/*.{tsx,jsx}` for components; detect suggests such a glob when it finds one package per component. Every script then runs from the root, as in any repo.
   - **One package**, when the root holds packages and nothing of its own: detect lists `nestedPackages` and finds no framework, no component folders and no style files at the root. At a workspace root the packages are its workspace members, not `nestedPackages`, and detect may take the framework from them, so take this branch too when the members are separate apps, or when the user works on one app of several. Ask which package, and re-run detect with `--root <package>`; inside a workspace it also reads what the workspace root installs and the story tool config kept there.

   When it is not clear, show the user both and recommend the root when the story tool or the tokens live there. A chosen package reaches init through `--root <package>` (step 4). Until init has written `massimo.config.json` there, only `--root <package>` reaches the package: a script run from inside it before then still reads the repo top. So pass the same `--root <package>` to detect and to `adopt.mjs scan` in step 3 too. From then on, run every script from inside that package (`cd <package>` first), or pass the same `--root <package>` to every script: a script finds the project from the folder it runs in, not from where the script lives, so a run from the repo top does not see a project kept in a package.
2. **Ask.** One round of questions, two at most. Use the host's question tool when there is one; otherwise ask in plain text with a recommended answer for each. Ask only what detection could not settle:
   - Who is driving: a designer, a developer, or both? (It sets how much code you show versus visuals.)
   - Confirm or correct the component folders and token files detect found.
   - The product, its users, and two or three products whose quality bar they want to match.
   - Brand feel in a few words, and the accessibility bar (WCAG A or AA; recommend AA for public products).
   - Which phases they want. Default: all of graph → stories → tokens → tidy → guard; Figma mirror only if they use Figma. Recommend the full path for a repo with no system yet; "graph + stories + ux" for a team that only wants the design loop. When detect found styling (style files with custom properties, a Tailwind config, theme files) but no token set, recommend starting with `/massimo:extract`: it proposes the whole system from what the code already uses (tokens for every family, a usage rule per primitive, a README) and does the graph, tokens and docs work in one sitting.
   - Where real content lives (staging API, seed data, fixtures), so mockups never invent data.
3. **Adopt, or the native lane.** If detect reports `adoptable` (a story lane or story tool, `ds:` keys of the repo's own, its own graph, ratchet or token list, a DESIGN.md), say what it found and recommend adopt: massimo keeps and drives the repo's own setup through its config, and runs beside the repo's own tools until the two agree, instead of generating a new one. Show the user what adopt would work from with `node <plugin>/scripts/adopt.mjs scan`, with `--root <package>` when step 1 chose a package, which writes nothing: each part it found and who depends on it. Once the project exists, `/massimo:adopt` takes it from there. Recommend massimo's native story lane only when there is nothing to adopt; it renders through the repo's own build, so what you see is what ships. If detect reports `storyTools.lane`, the repo already has a gated lane of massimo's kind: say so, keep it, and nothing is scaffolded. Record the choice.

   When the only thing to adopt is a story tool the team keeps (Storybook, Histoire, or Ladle kept as it is: `adoptable` lists nothing but that tool's stories), recommend skipping adopt instead. For Ladle, offer the csf lane first: adopt opts into it with `adopt.mjs config --write --lane csf`, and the lane serves Ladle's story files in place. Recommend the skip for Ladle only when the team turns that down; if they want the lane, recommend adopt. A kept tool's stories stay in it and serve as the story lane, and adopt would have nothing to configure, compare or cut over: for Storybook, detect already suggests the stories keys (`storyTools.storybook` names the main config they come from, and its notes say what to set by hand). Record the keep with `state.mjs decide "keep <tool> as the story lane" --why "<the user's reason>"`, and skip adopt in step 6 with that reason. If the user picks massimo's native lane over the tool instead, the stories skill writes the lane's own keys when it scaffolds.
4. **Create.** Run `node <plugin>/scripts/init.mjs --config-json '<json>'` with any corrections from step 2 (component globs, style files, projectDir), and with `--root <package>` when step 1 chose a package. Show the user what it created and skipped, including the package.json scripts it added, and its warnings. When a warning says a format check would flag the project folder or the config, offer to add what it names to the ignore file or the tool's config it names; init writes nothing there. A warning that a lint would flag the vendored scripts gets the same offer, for the ESLint config it names. When the repo has something to adopt, init sets the adopt phase to do.
5. **Ground.** Write `<project>/product.md` from the answers (replace the template's placeholders; leave a section as "unknown" rather than inventing). Record each answer that is a choice with `state.mjs decide`.
6. **Plan.** For each phase the user does not want: `node <project>/scripts/state.mjs set <phase> skipped --note "<why>"`, adopt included when they chose the native setup over the repo's own, or keep a story tool with nothing else to adopt (`--note "keeps <tool>"`). Then `state.mjs set setup done --note "<framework>, <styling>"`.
7. **Hand over.** Show the roadmap (`state.mjs show`), write STATUS.md's hand-written sections, and offer to start the next phase now by invoking its skill (`/massimo:<skill>`). When the user chose adopt, the next phase is adopt: invoke `/massimo:adopt`, which scans, plans, configures, shadows, proves, cuts over and retires, one class at a time. Scan proposes no path rules, so its configure step helps the user add rules to `graph.taxonomy.rules` for the files with no `ds:group` line.

## Resume

1. Run `node <project>/scripts/state.mjs show` and read `<project>/STATUS.md`.
2. **Scripts current?** Compare the vendored `<project>/scripts/lib/project.mjs` `SCRIPTS_VERSION` with `<plugin>/scripts/lib/project.mjs`. If the plugin is newer, offer `node <plugin>/scripts/init.mjs --update-scripts` and say what changed if the plugin's CHANGELOG says. After an update, rebuild the tokens once (`tokens.mjs build`) so the generated files carry the new header, and run `init.mjs` again only to see its warnings. A project whose tokens are still the `tokens.json` from before 0.2.0 can move to the 2025.10 format with `tokens.mjs migrate`; offer it, never run it unasked.
3. **Tell the user where things stand** in three lines: what is done, what is in progress (with its progress note), and the single next step. Mention open explorations from the ux loop and any open question in STATUS.md.
4. **Route.** If the user said what they want ("let's do tokens", "keep going on the checkout redesign", "extract the system"), go there. Otherwise propose the next phase. On a yes, invoke the phase skill: `adopt` (when the adopt phase is to do or in progress, or the user wants to bring an existing setup in; its ledger, shown by `node <project>/scripts/adopt.mjs status`, is where it stands), `graph`, `stories`, `tokens`, `tidy`, `guard`, `figma`, `extract` (graph, tokens and docs in one flow, for a repo that has styling but no system yet), or `ux <topic>` for an exploration.

## Rules

- Never overwrite an existing file during kickoff; init.mjs refuses, and so do you.
- Keep questions few and concrete. Defaults are fine; record them as decisions so they can be revisited.
- Talk to designers in outcomes (what they will see, what they decide); show code to developers on request.
- End every run with the session protocol's End steps (project.md).

Wersje

RepozytoriumWynikLicencja
Ta strona · darioabc/massimo100MIT
tilnoteio/tilnote-blog100MIT
dedujeong/gemba100Apache-2.0
nextwork-projects/ai-video-editor-cooked100MIT
wrg32786/aigent-os100MIT
T-X-R/codex-game-studio100MIT
alienfast/claude100MIT
ratomirjovanovic/pandaward100AGPL-3.0
khadinakbarlabs/citebase100MIT

Migawka bazy z 13.11.2026 · wersja paczki 0f0bf4aa483a (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

  • 100graph
    Buduje i utrzymuje graf systemu projektowego repozytorium: komponenty, ich użycie, właściwości, historyjki i tokeny CSS.
  • 90adopt
    Przejmuje istniejący zestaw systemu projektowego w repozytorium i przełącza go etapami, zamiast tworzyć nowy.
  • 90design-sync
    Odświeża stronę systemu projektowego w claude.ai z repozytorium po scaleniu zmian w tokenach lub dokumentacji.
  • 100design-link
    Wiąże repozytorium z projektem systemu projektowego claude.ai/design: wyświetla projekty, pozwala wybrać i zapisuje .ravenclaude/design-project.json, aby agent mógł czytać i edytować projekt.
  • 90design-system-coverage
    Ocenia kompletność kontraktu systemu projektowego i zapisuje spis pokrycia, z którego korzystają kolejne testy projektu.
  • 86onboard
    Konfiguruje Clause dla nowego użytkownika lub nowego systemu projektowego, gdy prosi o start i budowę z własnych zasobów.

Uwagi i zgłoszenia

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