# ship-it

Adopt this skill: https://proskills.md/skills/other/lunkibr-ship-it

Page: https://proskills.md/skills/other/lunkibr-ship-it
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: SKILL.md
size: 6158
upstream: https://github.com/lunkibr/ship-it/blob/HEAD/SKILL.md

```text
---
name: ship-it
description: Use this skill whenever building, reviewing, or auditing any product surface — a mobile app screen, a web app (in-product) screen, a marketing website page, or a cross-screen interaction flow — especially right before calling it done or shipping it. Start here to identify which section (mobile app, web app, website, flow, and more as they're added) the surface belongs to, then drill down to name every pattern (login, checkout, billing, pricing, admin panel, empty state, and more) it should have and flag which are missing — weighed against what this specific product actually is, never applied as a blind checklist. Trigger even when the user just says a screen or page is finished or asks for a review, not only when they say "checklist."
---

# Ship It

Catalog of product/UX patterns — one section per surface type (mobile app, web app, website, flow, more to come), one file per pattern within a section. Never load a pattern file, or a section you're not working in, before you need it.

## Steps

1. **Build a one-line picture of the product** — what it does, who it's for, and which capabilities it actually has (sells something, runs subscriptions, accepts uploads, has teams/multi-user accounts). Pull this from the code, README, or prior conversation first; ask the person directly only for the specific unknowns that would change a judgment call (see Judgment calls). This picture is what step 3 is weighed against — skipping it is what turns a checklist into noise.
2. **Identify the section(s) in scope** — mobile app, web app, website, flow, or a section added later (see `sections/`). A task usually touches one section; ask only if genuinely ambiguous.
3. **Open that section's index** (table below) and, from its pattern names, tiers, and one-liners alone, list which patterns the current project already has, is currently building, or lacks outright. Start from each pattern's tier as the default assumption, then weigh it against the picture from step 1 before naming a gap — see Judgment calls. Don't open a pattern file for this step.
4. **For each pattern actually being built, reviewed, or fixed right now**, open its reference file (linked from the section index) and check the implementation against every item in it, applying the same per-item judgment (an item needing a capability this product doesn't have is not a gap).
5. **Report gaps grouped by pattern**, pointing at the actual file/line. Separate what's clearly expected from what's worth confirming with the person rather than presenting both with equal certainty.

## Judgment calls

A pattern or item only counts as a gap if the product's own context calls for it — never because the section index lists it. Every pattern carries a **Tier**, set in its section index, that fixes the starting assumption before any product-specific reasoning runs — without it, "use judgment" has no anchor and drifts toward whichever way is less work.

- **Fundamental** — expected on virtually every product in the section, independent of business model (Security, Privacy, 404, Contacting support-adjacent basics). Assume it applies. Exclude only for a stated, unusual reason, and treat that reason with real suspicion — this tier is where waving something away costs the most (legal exposure, not just a rough edge).
- **Common** — expected on most products of this kind, with ordinary, real exceptions (Billing, Checkout, Making a card payment: most monetized products need some payment flow, but plenty of legitimate products are free or sales-led). Assume it applies unless the product picture from step 1 clearly rules it out; state the one-line reason when it does.
- **Conditional** — applies only once a specific, narrower capability is confirmed present, not just plausible in general (Cart, Adding to cart, Entering promo code: need multi-item purchase specifically, a narrower thing than "this product takes payment"). Assume it does **not** apply until that capability is confirmed; don't ask the person to build the capability just to satisfy the pattern.

This is why payment outranks cart even though neither is Fundamental: most products that charge money do so through some Common-tier payment flow, but only a subset of those need a Conditional-tier multi-item cart on top of it.

Beyond the tier itself:

- **Stage counts as context too.** A pre-launch waitlist page isn't missing a Pricing page; a two-person startup isn't missing a Careers page — both are absent on purpose, not by oversight, regardless of either pattern's tier.
- **Once the person has confirmed an exclusion, don't raise it again this session.** Accept the answer and move on — repeating a question the person already answered reads as nagging, not thoroughness.
- **When it's genuinely unclear, say so and ask** — don't silently assume a pattern applies (noise) or silently assume it doesn't (a missed gap presented as if it were checked).

## Sections

| Section | Patterns | Index |
|---|---|---|
| Sidekick (mobile app) | 20 | [sections/sidekick.md](sections/sidekick.md) |
| Control Room (in-product web app) | 10 | [sections/control-room.md](sections/control-room.md) |
| Storefront (marketing website) | 23 | [sections/storefront.md](sections/storefront.md) |
| Choreography (cross-screen flows) | 13 | [sections/choreography.md](sections/choreography.md) |

More sections are added as new categories are ingested — each gets one row here and one file under `sections/`, following the same shape.

## Cross-cutting patterns

Billing, Login, Account, Settings, Search, and Cart each show up in more than one section's index (a mobile app and a website both need a Cart, for instance). Each still resolves to exactly one reference file — the pattern was reviewed once, from whichever section index you reached it, never re-checked per section. Flow patterns overlap the other sections' patterns more loosely (e.g. "Resetting password" is a sub-flow of Login, "Deleting account" of Account) — until those are reconciled, treat a Flow pattern and a same-topic screen pattern as two different checks, not duplicates.
```

## File: README.md
upstream: https://github.com/lunkibr/ship-it/blob/HEAD/README.md

````text
# Ship It

[![Validate](https://github.com/LunkiBR/ship-it/actions/workflows/validate.yml/badge.svg)](https://github.com/LunkiBR/ship-it/actions/workflows/validate.yml)
[![License: MIT](https://img.shields.io/github/license/LunkiBR/ship-it)](LICENSE)

**A Claude Code skill that catches the boring-but-important details before you ship a screen or feature.**

It doesn't check your code — it checks the product surface around that code: login, checkout, billing, empty states, 404s, admin panels, and the other screens that follow well-known patterns and get half-finished anyway because nobody double-checked the boring stuff before calling it done.

## The problem

Most teams don't ship broken code. They ship *incomplete* screens: a login form with no "forgot password," a paywall with no restore-purchases button, a pricing page with no FAQ, a cancel-subscription flow that guilt-trips the user on the way out. None of that shows up in a test suite — it shows up later, in support tickets, one-star reviews, and App Store rejections.

This skill gives an agent a structured, opinionated catalog of these patterns — organized so it can be consulted cheaply and precisely, not dumped wholesale into every conversation.

## What this checks — and what it doesn't

ship-it looks for missing or incomplete **product and UX** details on a screen: a password field with no password-manager support, a paywall with no restore-purchases button, that kind of thing. It is not an accessibility scanner and not a security auditor. Passing every item in a pattern's checklist doesn't mean a screen is WCAG-conformant or secure — a real audit (axe, Lighthouse, a pen test) is still a separate, complementary thing to run. Standards like WCAG, Apple's HIG, and Nielsen Norman Group's usability research get cited inside individual checklist items because they're the most specific, checkable detail available for that one item, not because this skill verifies compliance with them end to end.

## Using it

Once installed as a Claude Code skill, it triggers on intent, not on the word "checklist":

> "I just finished the login screen, can you check it over before I ship?"
> "Building a pricing page for the new plan — what usually goes on one of these?"
> "Is our cancel-subscription flow missing anything?"

The agent picks the section, opens only that section's index, names what the product already has versus what a `Fundamental`/`Common` pattern would predict is missing, then opens only the specific pattern file it needs to check line-by-line.

### What comes back

For the login example above, a real answer looks something like this — a short list grouped by confidence, not a wall of checkboxes:

> Checked against the **Login** pattern (`Common` tier — assumed to apply, since this product has user accounts).
>
> **Already there:** email/password fields, password visibility toggle, forgot-password recovery.
>
> **Missing:**
> - **Credential autofill** — the password field has no `autocomplete="current-password"`, so password managers can't offer to fill it ([MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Attributes/autocomplete)).
> - **Non-revealing error states** — "Incorrect password" confirms the email is registered; a generic message avoids that leak.
> - **Rate limiting feedback** — five failed attempts just reload the same form, with no cooldown message ([NN/g, Visibility of System Status](https://www.nngroup.com/articles/visibility-system-status/)).
>
> **Not flagged:** SAML/SSO — this is a consumer product with no B2B customers, so it wasn't raised as a gap.

That last line is the tier system at work: a pattern, or a single item inside one, only becomes a reported gap when the product's own context calls for it, not because the checklist lists it.

## How it works

Checking a screen doesn't mean loading the whole catalog. An agent works through three narrowing steps: figure out which of the four sections the screen belongs to, open that section's short index to see which patterns apply, then open only the one or two pattern files it actually needs to check line by line. A login screen never pulls in the checkout catalog.

```
SKILL.md              →  a pure router: steps, judgment rules, and 4 section names
  sections/*.md        →  one flat index per section: pattern name + one-liner + tier
    references/*.md     →  one file per pattern: the actual checklist, opened only when that
                            exact pattern is the one being built or reviewed
```

Nothing upstream repeats what's downstream. `SKILL.md` doesn't know what's inside a Login checklist; a section index doesn't know what "Fundamental" means beyond the word itself. This is deliberate — see [ARCHITECTURE.md](ARCHITECTURE.md) for the full reasoning, including the two existing Claude skills this design borrows from (`impeccable`, `media-use`) and the Anthropic Agent Skills spec it follows (progressive disclosure, `<500`-line `SKILL.md`, one-hop reference files).

Three things make this more than a flat list of checkboxes:

- **Sections, not platforms.** The four sections — `Sidekick` (mobile app), `Control Room` (in-product web app), `Storefront` (marketing website), `Choreography` (cross-screen interaction flows) — are just entry points. A pattern like Login or Billing that shows up in more than one section still lives in exactly one reference file, so it's written once and never drifts into two contradictory versions.
- **Tiers, not a flat "does this apply?"** Every pattern is tagged `Fundamental`, `Common`, or `Conditional` — a fixed prior for how surprised the agent should be if it's missing, so "use judgment" has an actual anchor instead of drifting toward whichever answer is less work. Security and Privacy are `Fundamental` (assume they exist; excluding them needs a real reason). A payment flow is `Common` (assume it exists unless the product is free or sales-led). A shopping cart is `Conditional` (assume it *doesn't* exist until something multi-item is confirmed) — payment outranks cart because more products charge money than sell multiple items at once.
- **Judgment calls are explicit, not implied.** `SKILL.md` states the failure modes directly: don't nag a B2B tool about a Cart it doesn't need, but don't wave away a Privacy Policy just because the product is small. Once a person has answered a judgment call, the skill doesn't ask again.

## Status

All 59 indexed patterns across the four sections are written and pass `scripts/validate.py`. The one known gap: the Web App source note never ingested its own Login pattern, so Control Room resolves Login through Mobile/Website's shared file rather than having its own row yet — see `sections/control-room.md`.

| Section | Patterns indexed | Fully written |
|---|---:|---:|
| Sidekick (mobile app) | 20 | 20 |
| Control Room (web app) | 10 | 10 |
| Storefront (website) | 23 | 23 |
| Choreography (flows) | 13 | 13 |

`Billing` and `Login` were written by hand first and set the quality bar; the remaining 57 were generated from `generation/PROMPT.md` against that same bar (real citations only when confident they resolve to something real — WCAG 2.2, Apple's HIG/App Store Review Guidelines, Material Design, MDN, GOV.UK Design System, and Nielsen Norman Group's usability research), then spot-checked rather than trusted blindly. What's left is deepening citations further over time — Baymard Institute's e-commerce research is a natural next source for Cart/Checkout/Pricing specifically — not filling gaps.

## Project structure

```
SKILL.md                     the router — read this first
AGENTS.md                    repo layout, terminology, and rules for anyone extending this
ARCHITECTURE.md              design rationale: why one skill, why tiers, why these sections
CONTRIBUTING.md              how to propose a pattern or report a bad citation
sections/
  sidekick.md                mobile app pattern index
  control-room.md            web app pattern in
````
