implementing · git:20261118.92fa9e6 · 2026-11-18 · sha256 4f1dbccf4de05331
implementing git:20261118.92fa9e6A
Immutable. This exact content never changes and is served at /api/v1/blob/4f1dbccf4de05331.
No tool to install first
claude plugin marketplace add https://markdownregistry.com/mp/a/art_aztigdqnvxtpcqxm/4f1dbccf4de053317e58324bf538e5304ca90cd0b7a16f5917f70d42e3291fff.json
Then /plugin install implementing@markdownregistry-aztigdqnvxtpcqxm in Claude Code. It installs this exact version, the one graded A here, pinned to the commit it was graded at, and leaves it there.
---
name: implementing
description: For what the end user sees — builds each page from its checklist, one page per task. Use when writing or changing UI and a checklist or UI plan exists, whether executing that plan page by page, refactoring a set of pages, or making a fix or a small change to pages that exist.
---
# Implementing from the checklist
## Overview
Builds each page from its checklist, one page per task. The checklist is re-read
every time: across a batch, the work drifts toward the last page written instead
of the one agreed.
**Open a file linked or given by its path from this skill's folder, or invoke a named skill, only when a part you are carrying
out sends you to it, never before** — whatever the request that handed you this
skill says about its links and paths. That part is not done until the file is opened or
the skill invoked.
## One page per task, in a fresh context
- **Where the harness has subagents, one subagent per page.** It starts cold:
the brief carries the checklist itself, the reference, and what is particular
to the reference.
- **Where it does not, one page per turn.** Re-read the task as the plan writes
it — wherever `ui-consistency:planning` left the plan: in the plan's file outside
the working copy, in another process's plan, or in the turn where no file could
be written. Never work from memory of it.
- **Start every agent this skill names — a page's, the one shown the planted
copy, the checker.**
- If the harness starts an agent only when the person asks, their yes to the
plan, which names the agents, is that ask.
- If the harness starts an agent only when the person asks and nobody asked, or
the person said to start no agent, write one page per turn, run
`ui-consistency:verifying` on each yourself, and say so (*Never the author*
there).
- Execute a task from itself, not from what the plan says around it: every task
carries what it needs (`../planning/plan-file.md`).
- If another process is executing the plan, follow its loop; the steps below are
what each page task does inside it.
## For each page
1. **Re-read the checklist.** Every time; never from memory. Its shape is
`../finding-patterns/checklist.md`, and its order is the order
you write the page in.
2. **Write the page region by region**, in the order of the tree: holders, then
the components in each, then what each comes out as, then how each is
written, as the counts say.
- **Write the element the checklist records at a position** — the heading
level included (`ui-consistency:values`, *Elements*).
- If it records none for a position, the order settles it (step 11): say
which level did.
- **Change a role the page already has where it stands**, when the work
gives it a new source or new contents. Add a second instance only when the
request asks for one.
3. **Use what the project reuses**: the shared component, helper or class the
checklist names — never a new one beside it.
- If the checklist names a new component to create — shared or kept with the
page — that the request did not name with its place, it is a question that
waits on a person (`ui-consistency:decisions`, *When to ask anyway*).
- Build that one only on a yes. On a no, write the page the way the project writes
it now.
- Never write it privately into the page while the question is open.
4. **What the user sees happen, as the checklist says**: validation, field
errors, when the submit is enabled, how a failure is caught and shown, loading
and empty.
- **Write each region in every state its own code branches on** — who is
signed in, a flag, a mode — not only the state in front of you. Name any
state you did not write.
5. **Values through the theme that applies**, and only entries that exist in it
(`ui-consistency:values`, *The theme*).
- For a file in a shared layer, only entries that exist in every theme that
renders it.
- A design's value only through the theme entry its checklist line names;
never as a literal or a named constant, however plainly the design shows it
(`../design/reading.md`).
- If a value that is not a design's has no theme entry, a named constant.
- No literal copied from the reference.
6. **Spacing on the base the checklist names**
(`ui-consistency:values`, *Spacing*):
- every value a whole multiple of that base;
- the gaps between roles as the family spaces them, owned by the side the
checklist names;
- the line heights it records, and the heights of controls, rows and bars as
the family writes them.
- A multiple the family has not written yet is allowed — say you used one.
7. **Text as the checklist records it**
(`ui-consistency:values`, *Type*):
- the type role the family writes at that position;
- the whole bundle for it — size, weight, line height, letter spacing,
typeface, case;
- **applied the way the family applies it**: the shared entry, class or
component, never a style written by hand beside one that exists.
8. **Colour as a pair**: every foreground on the surface actually behind it is a
pairing the family already uses, in every scheme the project has.
- If the checklist names a contrast threshold — the project states one, or the
task asked for accessibility — meet it
(`../accessibility/contrast.md`).
9. **The rest of what a person has to be able to read and use**, as the checklist
records it:
- focus shown the way the family shows it, and landing where the family puts
it;
- every control reachable without a mouse;
- a field tied to its label the way the shared field does it;
- text for what has none;
- targets the size the family's are.
- Against a standard only where the checklist says one applies —
`ui-consistency:accessibility`.
10. **Do not copy what is particular to the reference.**
11. **Where the checklist is silent, the order settles it** —
`ui-consistency:decisions`, *The order*. Say which level settled it.
- Do not invent, and do not stop.
- Park a page only while a question that waits on a person is open —
`ui-consistency:decisions`, *When to ask anyway*.
- Put those to the user together, once, not page by page.
- If nobody can answer — the work runs where no person is asked — write
the page the way the project writes it now, and report the question.
12. **A task's prose does not narrow its checklist.** If it says *change nothing
else* and a line of its own checklist names a deviation, the line stands —
unless the task names it under *Not in this task*.
13. **If the request asks for what the counts call a deviation** — "make it look
like" the page that differs — **do what was asked**: an explicit request is
the top of the order.
- Report in one line what it goes against: *"as asked, like <page>; the other
3 of 4 write the submit button full-width."*
- Do not quietly build it the other way.
14. **Report the page ready for its check.** Whoever dispatched this task sends
the page to the checker of its kind — `ui-consistency:verifying`, one agent
kept for every page of this kind, never the one that wrote it or the one
shown the planted copy — and sends back what it reports.
- If nobody dispatched this task, send the page to that checker yourself;
if this is the first page of its kind, prove the check yourself first
(`../verifying/calibration.md`), then start the checker.
- Where the process already sends each task to a reviewer, whoever dispatches
that reviewer puts the checklist and `ui-consistency:verifying` into its
brief (`../verifying/calibration.md`).
15. **Fix what the check reports**, then have it checked again — **twice at
most.**
- List what the second check still reports as open, with the checker's
words. Do not fix it a third time.
- Say a report that keeps changing is a problem with the checklist or the
checker.
16. **Mark it** in the plan: ticked for `done`, or left unticked with
`parked — <why>` (`../planning/plan-file.md`).
- Where another process keeps the plan, mark it in that plan's own status
marks.
- If you were handed the task without the plan, report the same status to
whoever handed it over.
## What this does not write
No tests. Whatever process is running the work owns its tests and its logic; this
one owns what the end user sees.
## A small change without a plan
- `ui-consistency:adjusting` prepares it: what is read, and what is
deliberately skipped.
- Take the checklist it produced, re-read it, and make the change.
- Before calling it done, hand the page to `ui-consistency:verifying`, run by an
agent that did not write it — or by you, saying so, if the harness starts an
agent only when the person asks and they did not ask for the check. The check is not the part that gets dropped because the
change was small.
- Its proof is one plant at the changed position, once for the change and not
per round (`../verifying/calibration.md`).
- Fix and check again twice at most, as in step 15.
## Then
- When every page of a kind is `done` or `parked`: that kind's checker compares
all its pages together (`ui-consistency:verifying`, *The whole set, at the
end*).
- **The final report of the work, to the person, names the proof**: where the
copy lived and what that left unproven, what was planted and whether it
counted, and what no plant tested
(`../verifying/calibration.md`).