Przejdź do treści
Biblioteka skilli
Projektowanie i UX · Przegląd i audyt

impl-review

/impl-review

Recenzuje UX zbudowanego kodu, gałęzi lub działającej aplikacji metodą Invisible & Lean, z ocenami i dowodami file:line, i poprawia aż do poziomu bez zarzutów.

Repozytorium
claude-plugins ↗
Licencja
MIT
Ostatnia zmiana repozytorium
02.11.2026

Ocena i bezpieczeństwo

84/ 100Klasa: dobry
Format9 / 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 02.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

Recenzuje UX zbudowanego kodu, gałęzi lub działającej aplikacji metodą Invisible & Lean, z ocenami i dowodami file:line, i poprawia aż do poziomu bez zarzutów.

Wyzwalacze z opisu

Invisible & Lean

Argumenty

/impl-review [folder | file | branch | diff | URL] [max rounds]
Oryginalny opis (EN)

Review the UX of code, a branch or a running app AFTER implementation using the "Invisible & Lean" framework, with scores backed by file:line evidence; when the user asks for improvements, fix and re-score over several rounds up to masterpiece (flawless) level. Use when the user wants to review, evaluate or improve the UX of a screen, feature, module or app that has been built. Not for plans that are not built yet (use plan-audit).

Jak działa

  1. 0. Load the framework
  2. 1. Permission gate: read this before doing anything
  3. 2. Scope, scale, context
  4. 3. Find evidence in the code
  5. 4. Round 0 → improvement rounds
  6. 5. Final report
Sekcje z nagłówków SKILL.md, w oryginale · 108 linii, 1 220 słów
Podgląd SKILL.md
---
description: Review the UX of code, a branch or a running app AFTER implementation using the "Invisible & Lean" framework, with scores backed by file:line evidence; when the user asks for improvements, fix and re-score over several rounds up to masterpiece (flawless) level. Use when the user wants to review, evaluate or improve the UX of a screen, feature, module or app that has been built. Not for plans that are not built yet (use plan-audit).
argument-hint: "[folder | file | branch | diff | URL] [max rounds]"
---

# Review & improve UX (after implementation)

Input: `$ARGUMENTS`. If the last token is a standalone integer, it is the **maximum number of rounds**; the rest is the target.

## 0. Load the framework

Read `${CLAUDE_PLUGIN_ROOT}/references/ux-framework.md`. All scoring, severities, scale, improvement rounds, the masterpiece gate and stop conditions follow that file exactly. This skill defines only what is specific to code.

## 1. Permission gate: read this before doing anything

Decide the **mode** first, based on the user's exact request:

- **Improve mode**: the request explicitly says to fix / improve / apply (for example "review and fix it", "keep fixing until it passes").
- **Review-only mode**: every other case, including a bare `/invisible-ux:impl-review`.

In review-only mode: **don't use Edit / Write on project files (including the report file), and don't run commands that change project files**. The report is printed in the chat only. After round 0, print the report and end the turn with **one** question: improve everything up to masterpiece level, or only specific finding IDs? Non-interactive run → stop at the report. Once the user agrees → run the rounds without asking again each round.

## 2. Scope, scale, context

| Input | How to handle it |
|---|---|
| None / "diff" / branch name | The changes: `git diff <base>...HEAD` plus uncommitted changes (`git diff HEAD`, `git status --porcelain` for new files), plus the surrounding code needed to understand the flow. |
| File / folder | That module. |
| URL | With a browser tool → try it for real. Only type / submit / delete on **localhost or a dev environment**; any other URL → observe only, never submit data. |
| Screenshot | Evaluate from the image, combined with code if available. |

Pick the Small / Medium / Large scale per framework section 8. Look for an accompanying plan: a path the user gives in the input, otherwise `ux-plan-audit.md` / `plan.md` / a spec in the repo. If there is one, its **UX acceptance criteria** are a mandatory part of the masterpiece gate.

Context (who uses it, device / environment, frequency): infer it from code / plan; if you can't, bundle the question into the permission-gate question, or record assumptions.

Decide how to **verify**: the project's existing lint / type-check / test commands; how to run the app; whether a browser tool is available.

**Report file** (improve mode only): `ux-impl-review.md` in the same folder as the plan if there is one, otherwise at the project root. It is the only file created besides code changes.

## 3. Find evidence in the code

| Pillar | What to look for |
|---|---|
| Smart Defaults | Form initial values (`useState(...)`, `defaultValue`, `initialValues`, `v-model`…): which fields start empty even though they could be derived? Are filters / tabs / views remembered? |
| Forgiving | Delete / submit / overwrite handlers: confirmation or Undo, soft or hard delete. What `catch` / `onError` / interceptors show: do they dump `error.message`, error codes or server responses into the UI? Do validation errors reset the form? Are drafts saved, are requests retried? |
| Frictionless | Number of routes / modals / steps; full-screen blocking loaders; scroll position / filters lost when going back; input `type` / `inputmode`. |
| Zero Cognitive Load | Number of primary buttons per screen; vague labels; system terms leaking into the UI; consistency across screens. |
| Baseline constraints | Saving / offline indicators; confirmation for irreversible actions; touch targets, `aria-label`, color-only status; when permissions are requested. |
| Completeness & microcopy | All states present; long text, large numbers; pressed states, layout shift, focus; i18n files and hard-coded strings against the microcopy rules. |

Every finding has an ID and a `file:line`. Report only what you see in the code or when running it; unconfirmed suspicion → write "needs checking at runtime".

## 4. Round 0 → improvement rounds

Round 0 and the rounds follow framework section 10 exactly. Print the round 0 report and write it to `ux-impl-review.md` **before** the first change. Specific to this skill:

**Editing code safely**
- Before editing: record `git status`. If a file you are about to edit already has uncommitted changes from the user → say so in the report first.
- Revert **only with Edit, on the parts you changed yourself**. Never use `git checkout`, `git restore`, `git reset`, `git stash` or `git clean`. Don't commit.
- Follow the patterns / libraries / components already in the codebase. Don't add new infrastructure or libraries (framework section 8). When editing i18n → keep placeholders and update every language file together.
- Don't change the project's lint / test commands or check configuration. If you need to check a new file, run a separate command and record it in the report.

**Verification**
- Run the existing lint / type-check / tests. Checks that were already failing before your edits → record them in round 0; they don't count as your errors, but the number of failures must not grow.
- Gate #5 requires **running it for real**: run the app (dev server or browser tool), walk through every main task, re-count taps, reproduce each error scenario (network lost, wrong input, back, reload midway…), and record evidence in the report. Reading code without being able to run it → **Excellent** at most; say what is needed to run it.
- If you need a dev server: pick a free port (check with `lsof -i :<port>`), bind to `127.0.0.1`, confirm the page really is this app, and **shut the server down when you finish** (including when stopping midway).

**Fresh eyes** (2 subagents) evaluate the code scope / URL (absolute paths). Tell them explicitly not to edit files and not to submit data.

## 5. Final report

Write the full report to `ux-impl-review.md`; in the chat print: the Result line, the Scores table, Changes made (summary), Remaining gap, Next steps, and the file path. Small scale → ≤ 1 page.

```markdown
# UX review: <name>

**Mode**: <review only / improve> · **Scale**: <Small / Medium / Large> · **Upgrade scope**: <tasks>
**Context**: <users> · <device / environment> · <frequency> — <assumptions>
**Result**: <Round 0: level X> → <after n rounds: level Y> · Stopped because: <stop condition> · Gate #6: <2 independent subagents / self-check → Excellent at most>
**Verification**: <commands run, results>

## Scores (round 0 → final)
| Pillar | Round 0 | Final | Open findings |
|---|---|---|---|
| Zero Cognitive Load | | | |
| Frictionless Flow | | | |
| Smart Defaults & Context | | | |
| Forgiving & Invisible | | | |
| Baseline constraints | | | |
| Completeness checklist | x/n | x/n | |

## Taps per main task
| Task | Round 0 | Final | Minimum (calculation) |
|---|---|---|---|

## Acceptance criteria check (if there is a plan)
| Criterion | Result | Evidence |
|---|---|---|

## Round log
| Round | Scores CL/FF/SD/FI | Open Crit/High/Med/Low | Fixed | Verification |
|---|---|---|---|---|

## Findings
| ID | Severity | Pillar | Location | Current → Improved | Status |
|---|---|---|---|---|---|

## Remaining gap to masterpiece level
## Next steps (backend / infrastructure / product decisions / out of scope)
## Doing well: keep as is
```

Wersje

RepozytoriumWynikLicencja
Ta strona · gofkai/claude-plugins84MIT
brave/brave-core100AGPL-3.0

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

  • 84plan-audit
    Audytuje UX planu, specyfikacji lub makiety przed wdrożeniem metodą Invisible & Lean i poprawia plan aż do poziomu bez zarzutów, z kryteriami akceptacji UX.
  • 100impl-task
    Realizuje zadanie według jego planu implementacji, w ciągu create-task, clarify-task, plan-task, impl-task, review-code, review-task i ship-task.
  • 10031-review-impl-gated
    Przegląda kod w aktywnym przebiegu: druga instancja Claude sprawdza zbudowany kod względem planu i ocenia problemy.

Uwagi i zgłoszenia

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