UX Maximizer

Take a project that works and grind it until it feels premium. Not one polish pass: a vision, implemented, then ground down through repeated audit → polish → design-intelligence cycles until the passes stop finding anything worth changing.

Core Insight: Taste is a process, not a flash. A premium feel doesn't come from a single pass; it comes from a bold vision (idea-forge) implemented, then sanded smooth by repeated cycles. Like its sibling project-autopilot, this is a successive-prompter: each stage's instruction fires only when the prior stage finishes (one thing at a time, done well), and a green ratchet means the app never breaks while it's being beautified. Design taste stays the user's. The skill does the work, the user's eyes sign off.

Preconditions / guards (check before Phase 1)

1. The app works. UI/UX maximization is a maturity activity: you beautify a working thing, not a broken one. If core function is broken, fix that first.
2. Green baseline + checkpoint. The ratchet needs a recoverable starting point.
3. ⚠️ Late-stage ideation guard (standing rule): the Phase-1 idea-forge run is a mass-dispatch that can destabilize a mature project. If the project is late-stage (>10 modified files OR >3 in-flight beads), STOP and confirm with the user before ideating.

The Pipeline (staged: issue each prompt only when the prior finishes)

Phase 0: Orient

Read the project. Understand three things: what it is, who the user is, and the current UI/UX state (screens, flows, components, the existing design language). Checkpoint a green baseline.

Phase 1: WOW vision (idea-forge)

Run idea-forge with the verbatim creative-unlock prompt (it's calibrated to break the model out of trained incrementalism; see references/PROMPTS.md). Rank the output; take the top 5 recommendations.

Phase 2: Implement the top 5

Operationalize the 5 into beads (beadsmith), then implement them one at a time, each under the green ratchet with its own checkpoint. Design taste is the user's: after each (and especially for a bold direction change), show the running result / screenshots and let the user gut-check before it's banked. A redesign direction is an ask-user decision, a routine refinement is auto.

Phase 3: The quality cascade (the calibrated counts)

Once the 5 are in, run the cascade in this order, each via deepen with progressive deepening, every pass's findings fixed under the green ratchet:

• 3× ux-scan: heuristic + accessibility evaluation → fix findings
• 5× polish-pass: iterative visual elevation toward Stripe-level quality
• 3× design-intel: design-intelligence passes (styles, palettes, type, layout)

(5 / 3 / 5 / 3 are the calibrated starting counts, tunable per project.)

Phase 4: Exhaust until complete

Loop Phase 3 until saturation: passes stop surfacing material improvements (diminishing returns, not literal zero). If a pass reveals a genuinely new premium direction, re-ideate (back to Phase 1, guard re-checked) rather than grinding the old one. Then surface the before/after to the user for final taste sign-off (the user's QA move) and write a short done report.

Verify by looking (not just by passing)

UI/UX cannot be proven by a green test suite; it has to be seen. After passes, actually run the app and capture what it looks like (use /run or /verify if installed, or start it yourself; for webapps, screenshot the key flows). Tests prove it still works; only eyes prove it looks premium. The user is the final visual QA.

Shared mechanisms (inherited from project-autopilot)

Green ratchet (every change ends build+tests+smoke green or reverts), decision inbox (taste/direction calls queue for the user), saturation-based convergence, and capability-aware execution (solo by default; ntm swarm optional when installed) all work as they do in project-autopilot; see that skill's CONVERGENCE.md / SAFETY-RAILS.md / EXECUTION.md rather than duplicating them here. Integration: project-autopilot's UX lens can route a project here for the exhaustive treatment.

Skills it orchestrates

idea-forge · ux-scan · polish-pass · design-intel · deepen · beadsmith · unslop (UI copy). Optional, if installed (otherwise the core skills above cover the work): premium-palette-design (palette work) · interactive-visualization-creator (data viz) · mobile-retrofit-for-webapps (mobile gaps) · run / verify (look at the result).

THE EXACT PROMPT

/ux-maximizer
Target: <project path>
Counts: <ideas/ux-scans/polishes/design-intel; default 5/3/5/3>
Mode: solo (default) | swarm (optional; needs ntm installed)

Anti-Patterns

• One polish pass and calling it "premium". Taste is a process, not a flash.
• Running the Phase-1 idea-forge mass-dispatch on a late-stage project without asking (the guard exists for exactly this).
• Beautifying a broken app. Function first, beauty second.
• Auto-banking a bold redesign direction without the user's taste gut-check.
• Trusting "tests pass" as proof it looks good. You have to look at it.
• Grinding the same cascade past saturation instead of re-ideating a fresh direction.

References

• PROMPTS.md: the verbatim wow-prompt for idea-forge + cascade spec