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

design-forge

/design-forge

Planuje pracę projektową UI z użytkownikiem przed kodem: czyta aplikację, pokazuje ekrany, proponuje trzy kierunki i bramkę zatwierdzenia planu.

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

Brak sygnałów. Repozytorium zmienione 12.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 sprawdzić przed instalacją
  • 1 skrypt w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/mock-lint.mjs

Co robi i kiedy

Planuje pracę projektową UI z użytkownikiem przed kodem: czyta aplikację, pokazuje ekrany, proponuje trzy kierunki i bramkę zatwierdzenia planu.

Oryginalny opis (EN)

Plans UI design work with the user before any code is written. Reads the app, shows the current screens, deals three visual directions to choose from, and presents a plan with a design section, a responsive matrix and a gate that approve-plan and ship-plan carry through to a pull request. Covers new pages, app screens and components, redesigns, restyles and design reviews, user flows across screens, design-system cleanup, and native iOS and Android apps. Use when the user wants to design, redesign, review or polish a UI, improve a flow, make a page mobile friendly, tidy colours and sizes, or p

Jak działa

  1. 1. Prerequisites
  2. 2. Pick the mode
  3. 3. Responsive matrix
  4. 4. Discover
  5. 5. Decide on a lavish page
  6. 6. The plan
Sekcje z nagłówków SKILL.md, w oryginale · 145 linii, 1 664 słów
Podgląd SKILL.md
---
name: design-forge
description: Plans UI design work with the user before any code is written. Reads the app, shows the current screens, deals three visual directions to choose from, and presents a plan with a design section, a responsive matrix and a gate that approve-plan and ship-plan carry through to a pull request. Covers new pages, app screens and components, redesigns, restyles and design reviews, user flows across screens, design-system cleanup, and native iOS and Android apps. Use when the user wants to design, redesign, review or polish a UI, improve a flow, make a page mobile friendly, tidy colours and sizes, or plan screens for a mobile app, before implementing it. For non-UI changes use forge.
---

<instructions>

Plan a design change with the user. Do not write app code. Wait for approval.

This skill adds design to the **forge** skill. It does not replace it. Follow forge for the Record (Step 0), sizing with pick-tier (Step 0.5), the Socratic rules, lettered options, probing risky guesses, and the plan format with its length caps (Instructions 1-4). Do not copy forge's text here.

The visual work uses **taste** (the design-taste-frontend skill). Its commands are named below. Run them as `node <taste>/scripts/<name>.mjs`.

## 1. Prerequisites

Do this before any question.

- Find `<taste>`: the folder the harness reports when it loads the design-taste-frontend skill (Claude Code shows it as the skill's base directory). If the harness reports none, use the `design-taste-frontend` folder next to this skill's folder.
- Run `node --version`. Taste needs Node 22 or later.
- Look for Chrome, Edge or Chromium.
- Taste or Node missing, or taste found without `scripts/start.mjs` or `scripts/consistency.mjs`: say which one is missing, print "Update the design-taste-frontend skill to the latest release with the tool you installed it with.", and stop.
- Chrome missing: planning goes on. Every Gate criterion becomes `manual:`, with the reason.
- Every taste script that opens Chrome gets `--profile "${TMPDIR:-/tmp}/taste-profile-<task>"`. This folder is outside the repo.
- Native work also needs `xcrun simctl` (iOS) and `adb` (Android). Each one missing makes that platform's capture criteria `manual:`, with the reason.

## 2. Pick the mode

State the mode in one line with the reason. Then read only that mode's file.

| Signal in the request | Mode | File |
|---|---|---|
| New page, landing, site, hero; new dashboard, settings, queue, screen; one component | create | [modes/create.md](modes/create.md) |
| Redesign, restyle, "looks dated" or "AI-made", review or audit a page, missing states, fix mobile | redesign | [modes/redesign.md](modes/redesign.md) |
| Steps, clicks, funnel, onboarding, checkout, drop-off, a journey across screens | flow | [modes/flow.md](modes/flow.md) |
| Tokens, colours or sizes everywhere, tidy the design system, export to Figma | system | [modes/system.md](modes/system.md) |
| `*.xcodeproj`, `Package.swift`, `pubspec.yaml`, React Native (`app.json` and `react-native`), or the user names iOS or Android | native, with one mode above | [modes/native.md](modes/native.md) |

- "Improve the design system" with no other signal: ask one chat question. A) Clean up the code (system mode). B) Export to Figma (system mode, hand-off only). Recommend A.
- **Page or app screen** is the first decision. Record it with the mode. A page also records taste's kind: software, gaming, tech, product, service or place.
- **Mixed** (a page plus the app behind it): one Look for both.

## 3. Responsive matrix

Applies to every mode.

- Name the target widths. Default `1440,1024,820,768,390`. Mobile-first adds `375`, and the mock is shown at phone width first.
- Native: name the simulator devices instead.
- The phone is its own layout. Decide each changed screen's phone layout now (pages: taste `references/layout-v4.md`; app screens: `modes/app.md`).

## 4. Discover

Read the app. Never edit its source.

- Taste output goes only to `.plans/<task>/taste/`. Run taste from the repo root, except `start.mjs deal`:
  - `start.mjs deal`, from `.plans/<task>/taste/`: `--history history.json`.
  - `start.mjs css`: `--history .plans/<task>/taste/history.json`.
  - `deal.mjs`: `--history .plans/<task>/taste/layout-history.json`.
  - `consistency.mjs`, `check.mjs`, `shoot.mjs`: `--out` (or `--shots`) `.plans/<task>/taste/<before|mock|after>`.
- Taste defaults to `.taste-skill/` in the working directory when you leave these out. Never write it outside `.plans/<task>/taste/`.
- Choose the task slug here. approve-plan reuses it.
- Run the steps in the mode file.

## 5. Decide on a lavish page

Load the lavish skill, else run `npx -y lavish-axi --help`. Put the page in `.lavish/`. Never run `lavish-axi share`: shares are public.

- **Tier S:** no page, no dialogue, no deal. A short plan in chat. Tier S has no Verify; Build runs the Gate line after the look loop.
- **Tier M:** the three direction mocks (below) and any trade-off question on a page. The plan in chat.
- **Tier L:** the three direction mocks, then the plan as a page. After the pick, the picked mock is captured at every named width.

Modes with no deal (polish, review only, component) are unchanged. So are system and flow, unless they deal.

What the page shows:
- Before screenshots with findings pinned.
- The three direction mocks of the key screen (see The directions): screenshots at the desktop and phone widths, the self-check table from [references/directions.md](references/directions.md), and the adoption count. The recommended direction is marked.
- The idea sentence and the competitor test.
- The flow map and the state table, when the mode makes them.
- Questions as lettered options, the recommended one marked.

### Look source

Take the first that fits. Details of the policy: [references/directions.md](references/directions.md).

1. **Adoption test.** Count the app's screens. At least 5, and at least 90% of them take colours and fonts from tokens or shared components: the system is fully adopted. **Locked.** `Look: system`, no deal, all three directions stay inside it. State the count on the page; the user can overrule it.
2. **Tokens present, not fully adopted.** Direction A keeps them (`Look: system`). B and C deal (`Look: deal`). If the user picks B or C, the plan's phases say the tokens are replaced.
3. **Brand.** The user gives brand colours, and maybe fonts, or says the brand is locked (then treat it as step 1): `node <taste>/scripts/start.mjs brand --page <kind> --bg ".." --ink ".." --accent ".." --type <id> --radius soft`. A font outside taste's ids: take the nearest id from `start.mjs types --page <kind>`, then swap the `--font-display` and `--font-text` lines by hand. Log the swap as an allowance.
4. **Deal.** `node <taste>/scripts/start.mjs deal --page <kind> --history <file>` gives 3 palettes and 3 type pairings. Pair them into three directions; the user picks a direction. Then `start.mjs css --page <kind> --palette <id> --type <id> --radius sharp|soft|round --history <file>` prints the tokens. A page also runs `node <taste>/assets/layout/deal.mjs --type <software|product|place|service> --has <photo,ui,object,film> --history <file>` for the hero. Hardware: `--type product --kind tech`. A game: `--type software --kind gaming`, and `--has` must name what the brief has (`film` or `photo`). A place's hero is printed, not dealt, and a place always uses `start.mjs brand`.

Run `start.mjs deal` with the working directory set to `.plans/<task>/taste/` and `--history history.json`. It writes `.taste-skill/build.json` in the working directory whatever `--history` says. Run `css` and every other command from the repo root with `--history .plans/<task>/taste/...`, even though `deal`'s `then:` line prints `--history history.json`.

Deal again only on request or for a stated reason: it contradicts the brand, it needs a missing asset, or the accent is violet (taste bans violet; a violet brand accent is an allowance with its reason).

A brand-new site takes taste's starter kit (`<taste>/assets` into the project, plus `starter.html`). An existing app takes only the `:root` tokens and font links, mapped into its own styling. Copy no kit into it.

### The directions (tier M and L)

Before the user picks, build three mocks of the one key screen, with real content. Follow [references/directions.md](references/directions.md) for the bundle, the representation table and the difference rule. Mocks live in `.lavish/<task>-mock/<a|b|c>/`.

1. Pages: build the first screen from the kit's `starter.html` and the dealt hero. Copy `<taste>/assets` beside each mock (lavish serves relative paths only). App screens: static HTML from the tokens.
2. From the repo root, print each mock's tokens with `start.mjs css --history .plans/<task>/taste/mock-history.json`. After the pick, run it once more with `--history .plans/<task>/taste/history.json`.
3. **Tidy gate**, on every mock before the user sees it:
   1. Copy `assets/mock-base.css` (this skill) beside the mock. Link it first.
   2. One class per repeated component. Each repeating slot holds its longest real value.
   3. `node <this skill>/scripts/mock-lint.mjs .lavish/<task>-mock/<a|b|c>`. Exit 1 is a FAIL.
   4. `node <taste>/scripts/consistency.mjs <mock>/index.html --widths <desktop>,<phone> --profile <dir> --no-rhythm --no-tiles --no-visuals --no-address --json --out .plans/<task>/taste/mock/<a|b|c>`. Exit 1 is normal. Read `checks`: only `cut-text`, `overlap-text`, `collide` and `off-viewport` block.
   5. At most 3 fix rounds. A mock still failing is shown with the failure labelled.
   6. No Chrome: lint still runs, and the mock is labelled "layout not checked".
4. Capture each mock at the desktop and phone widths: `node <taste>/scripts/shoot.mjs --url <mock>/index.html --w <width> --out .plans/<task>/taste/mock/<a|b|c>/<width>.png --profile <dir>`. Copy the PNGs beside the lavish page and show them with the self-check table.
5. After the pick, tier L captures the picked mock at every named width.

The mocks are throwaway. They never become app code.

## 6. The plan

Use forge's format. Add a `## Design` section in this shape. approve-plan copies it verbatim into `design.md`.

```markdown
## Design
- Plan folder: .plans/<task>/
- Mode: <mode>[ + native] · kind: page|app|mixed|component
- Look: system|brand|deal · kind <kind> · palette <id> · type <id> · radius <r> · hero <id> (pages) · font swap <face> (or none) · history .plans/<task>/taste/
- Direction: <name> · <one line>
- Representation: <datum: form>…
- Allowances: <check id — reason>… (or none)
- Idea: On this page, <thing of the subject> becomes <device>. Live thing: <…>
- Argument and copy outline: <one claim per section; headlines ≤ 2 lines; sample content flagged>
- Pictures: <exists | found with licence | drawn>…
- Widths: <list> · native devices: <list> · phone layout: <per screen>
- Frame (native only): <which parts follow the platform>
- Flow map: <current → proposed steps, or "n/a">
- States: <screen × empty|zero|loading|error|success|no-permission table>
- Tokens (system mode): .plans/<task>/taste/tokens.md
- Before: .plans/<task>/taste/before · FAIL <n> WARN <n>[ · rubric <n>/10 (app screens)]
- Gate (page): consistency.mjs exit 0 · check.mjs exit 0 · perf.mjs no FAIL row · at <widths>
- Gate (app): consistency.mjs app filter (modes/app.md) no FAIL · rubric after ≥ before
```

The Gate (page) commands. `<w>` are the named widths:

```
node <taste>/scripts/consistency.mjs <file> --widths <w> --profile <dir> --page <kind> --category "<what is sold>" --primary "<main action>" --out .plans/<task>/taste/<before|after>
node <taste>/assets/layout/check.mjs --url <file> --profile <dir> --sizes <WxH list> --shots .plans/<task>/taste/<before|after>/layout
node <taste>/scripts/perf.mjs <file> --profile <dir>
```

Acceptance criteria always include the gate line. A criterion only a person or a real device can check is `manual:`.

</instructions>
Pliki w paczce (11)
  • SKILL.md 12 KB
  • agents/openai.yaml 1 KB
  • assets/mock-base.css 1 KB
  • modes/app.md 2 KB
  • modes/create.md 3 KB
  • modes/flow.md 2 KB
  • modes/native.md 2 KB
  • modes/redesign.md 3 KB
  • modes/system.md 2 KB
  • references/directions.md 3 KB
  • scripts/mock-lint.mjs 3 KB

Wersje

W bazie nie ma innych skilli o nazwie design-forge.

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

  • 100form-mobile
    Projektuje ekrany aplikacji mobilnych iOS i Android, interfejsy mobilne i przepływy, np. onboarding, checkout i ekran główny.
  • 95mobile-taste
    Projektuje ekrany, nawigację i animacje aplikacji React Native i Expo tak, by nie wyglądały na wygenerowane przez AI.
  • 95mobile-app-design
    Projektuje, przerabia i przegląda ekrany natywnych aplikacji mobilnych na iOS i Androida w SwiftUI, UIKit, Compose i React Native.
  • 90design-boss
    Projektuje i poprawia wyraziste ekrany i przepływy mobilne dla iOS, Androida i aplikacji wieloplatformowych, z kontrolą wizualną.
  • 100mobile-design
    Projektuje, przegląda i przebudowuje natywne ekrany i ścieżki iOS i Androida: komponenty, nawigację, dotyk, dostępność i ruch.
  • 100mobile-redesign-screen
    Przeprojektowuje jeden ekran React Native lub przepływ 2 do 3 ekranów: wyciąga tokeny, ocenia ustalenia i modernizuje w atomowych commitach ze zrzutami przed i po, zachowując nawigację.

Uwagi i zgłoszenia

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