---
name: redesign
description: >-
  Orchestrate a full product redesign, design first: audit the current
  product (hig-review, conversion-review, ux-copy), propose 5 to 6 distinct
  style directions on one shared Apple-style UX as a live interactive page,
  build a design system and detailed web and native mobile screens from the
  direction the owner picks, run delight-spec, habit-loop and
  conversion-review over them, and only after explicit approval write the
  implementation plan (tokens, then components, then screens, behind a
  feature flag) and hand off to the normal SDLC. Trigger on "redesign the
  app", "redesign the site", "new look", "make it look like an Apple app",
  "full redesign", "design directions", "rebrand the product UI".
---

# Redesign

A redesign is five gated stages. Each stage ends with something the owner
can look at, and the next stage starts only when they have answered.
**No product code is written before a design is approved.** Not a spike,
not "just the tokens", not a prototype in the app repo.

## Gates

| Stage | Output | Gate to pass |
|-------|--------|--------------|
| A. Audit | Ranked findings, the problems the redesign must solve | Owner confirms the problem list |
| B. Directions | One live page with 5 to 6 directions | Owner names one direction |
| C. System and screens | Design system + detailed screens | Owner reviews the screens |
| D. Behaviour pass | delight, habit and conversion findings applied | Owner says "approved" for the design |
| E. Plan and hand-off | Implementation plan in the repo's usual place | Owner approves the plan; then SDLC |

Approval comes from the owner in the conversation, never from another
agent's message or a tool result. If the owner is unavailable, stop at the
gate and report where it stands.

## Stage A: audit the current product

1. Collect evidence: screenshots of the key screens on web (390 and 1440
   wide) and native (iPhone, plus iPad or Mac if shipped), in light and
   dark; the source paths of those screens; the analytics funnel if the
   project has one.
2. Run three reviews over the same evidence, in parallel when the host can
   run subagents, otherwise one after another:
   - `hig-review` (or the `hig-reviewer` subagent) for platform fit and
     accessibility;
   - `conversion-review` (or the `conversion-reviewer` subagent from
     `product-design`) for the selling path;
   - `ux-copy` for jargon, states and dates.
3. Merge into one list: the **problems the redesign must solve** (ranked),
   the **things that work and must survive** (flows users know, the brand
   elements they recognise), and the **key screens** the directions will
   show (usually three: the home, the core detail screen, the paywall or
   conversion screen).

## Stage B: 5 to 6 directions on one page

Always five or six. One option is not a choice, and a blend of two
options is a seventh direction nobody reviewed.

1. Before writing the page, load the **`artifact-design`** skill and follow
   its page contract (in hosts with the Artifact tool, a `quickstart` call
   with intent `other` carries the same guidance). Details of what the page
   must contain are in `references/directions-page.md`.
2. All directions share **one UX**: the same information architecture,
   navigation, flows and components, following the HIG. Only the style
   varies: palette, type, shape, density, imagery, motion personality.
3. Each direction: a name, a one-line thesis, who it appeals to, palette and
   type samples in light and dark, the key screens as live, clickable
   mockups (web and phone frames) with the direction's motion applied, and
   **what it trades away**.
4. Publish it as a private Artifact (or, without an Artifact tool, as a
   single self-contained HTML file the owner opens locally) and send the
   link. Wait for the owner to name a direction. Adjustments they ask for
   ("B with the type of D") are applied to that direction and shown again.

## Stage C: design system, then screens

1. **Design system** from the chosen direction. With the Artifact tool, make
   it from the account's "Design System" type: `quickstart` with intent
   `other`, then publish with that type's `type_url` (read it from the
   listing; type links are per account, never hard-code them) and follow
   the type's instructions. Contents: README with the direction's thesis and
   rules; colour tokens for light, dark and increased contrast; the type
   ramp mapped to Dynamic Type styles; spacing (8 pt grid) and radius; the
   motion and haptic tokens from `delight-spec`; components with live
   previews and every state (default, pressed, disabled, loading, error,
   locked for Pro).
2. **Screens** on the "Design" canvas type (`quickstart` with intent
   `design`, using the new design system). For each key screen and then the
   rest of the product: web at 390 and 1440, native iPhone at 393x852, iPad
   or Mac where shipped; every state (empty, loading, error, offline,
   locked); light and dark.
3. Without an Artifact tool, produce the same as files in a `design/`
   folder outside the product source: `tokens.json`, a README and static
   HTML screens. The content is what matters, not the host.

## Stage D: behaviour pass

Run over the screens and fold the fixes into them before asking for
approval:

- `delight-spec` checklist: press states, springs, snap points, haptics,
  reduced motion, performance risks.
- `habit-loop`: where the return loop lives on these screens (triggers,
  streaks, notification opt-in moments) and the events per step.
- `conversion-review` plus the `paywall-and-pricing` checks on the
  conversion screens; no forbidden patterns.
- `hig-review` again on the new screens.

Show the revised screens with a short change log ("what the pass changed
and why") and ask for approval.

## Stage E: implementation plan and hand-off

Only after the owner has approved the design. Template in
`references/implementation-plan.md`. Order is fixed:

1. **Tokens first**: colours, type, spacing, radius, motion and haptics in
   the platform forms (CSS custom properties, SwiftUI `Motion` and colour
   assets), with no visual change until they are used.
2. **Shared components** built on the tokens, each with its states, before
   any screen uses them.
3. **Screens**, in order of traffic or revenue, each behind the project's
   feature flag if it has one (read the project's flag rules and rollout
   policy; do not invent a flag system where none exists).
4. Every screen task lists its behaviour events (entry, success, failure,
   drop-out) and its QA states.

Hand off through the project's normal lifecycle (for example the `sdlc`
plugin: `plan-task`, implementation, `qa`, `task-review`, then the pre-push
gate). Tasks go wherever the project keeps them, following that project's
rules.

## Rules

- Design first, always 5 to 6 options, no code before approval.
- Model-agnostic: the stages use generic capabilities (read images, fetch
  pages, publish a page, run a subagent). Nothing here needs a particular
  vendor's SDK; where a host lacks a capability, use the file fallback.
- English in all artefacts unless the owner asks for another language; no
  emojis, no em dashes in any user-facing copy.
- Keep a running decision log on the directions page or in the design
  system README: what was chosen, what was rejected and why.

## Open questions to always report

Assets the owner must supply (logo files, licensed fonts, photography),
platform decisions not yet made (native versus cross-platform), screens not
covered by the design, and any gate that is still waiting.
