OpenParable
Skip to content
← Back to skills

Team UI Polish

Design
team-ui-polish

Team UI Polish is an Agent Skill for design published in the catlog22/maestro-flow repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

Unified team skill for UI polish. Auto-discover and fix UI design issues using Impeccable design standards. Anti-AI-slop detection, color/typography/spacing quality, motion, interaction states, visual hierarchy. Uses team-worker agent architecture. Triggers on "team ui polish", "ui polish", "design polish".

View on GitHub ↗
QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

  1. Open your project in Codex.
  2. Copy and paste the prompt below.
  3. Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/catlog22/maestro-flow/blob/HEAD/.claude/skills/team-ui-polish/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/team-ui-polish, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

<required_reading> @~/.maestro/workflows/run-mode.md </required_reading>

Team UI Polish

Automatic UI quality improvement pipeline: scan -> diagnose -> optimize -> verify. Built on team-worker agent architecture -- all worker roles share a single agent definition with role-specific Phase 2-4 loaded from roles/<role>/role.md.

Architecture

Skill(skill="team-ui-polish", args="task description")
                    |
         SKILL.md (this file) = Router
                    |
     +--------------+--------------+
     |                             |
  no --role flag              --role <name>
     |                             |
  Coordinator                  Worker
  roles/coordinator/role.md    roles/<name>/role.md
     |
     +-- analyze -> dispatch -> spawn workers -> STOP
                                    |
                    +-------+-------+-------+
                    v       v       v       v
           [team-worker agents, each loads roles/<role>/role.md]
          scanner  diagnostician  optimizer <-> verifier (GC loop)

Role Registry

RolePathPrefixInner Loop
coordinatorroles/coordinator/role.md----
scannerroles/scanner/role.mdSCAN-*false
diagnosticianroles/diagnostician/role.mdDIAG-*false
optimizerroles/optimizer/role.mdOPT-*true
verifierroles/verifier/role.mdVERIFY-*false

Pre-load (coordinator, before dispatch)

  1. Codebase docs: If .workflow/codebase/ARCHITECTURE.md exists, read for module boundaries
  2. Specs (ui): maestro load --type spec --category ui — load ui constraints as shared context
  3. Specs (coding): maestro load --type spec --category coding — load coding constraints as shared context
  4. Wiki knowledge: maestro search "UI polish design quality" --json — top 5 entries as prior context
  5. All optional — proceed without if unavailable

Role Router

Parse $ARGUMENTS:

  • Has --role <name> -> Read roles/<name>/role.md, execute Phase 2-4
  • No --role -> @roles/coordinator/role.md, execute entry router

Shared Constants

  • Session prefix: UIP
  • Session path: .workflow/.team/UIP-<slug>-<date>/
  • CLI tools: maestro delegate --mode analysis (read-only), maestro delegate --mode write (modifications)
  • Message bus: mcp__maestro__team_msg(session_id=<session-id>, ...)
  • Max GC rounds: 2

Worker Spawn Template

Coordinator spawns workers using this template:

Agent({
  subagent_type: "team-worker",
  description: "Spawn <role> worker for <task-id>",
  team_name: "ui-polish",
  name: "<role>",
  run_in_background: true,
  prompt: `## Role Assignment
role: <role>
role_spec: <skill_root>/roles/<role>/role.md
session: <session-folder>
session_id: <session-id>
team_name: ui-polish
requirement: <task-description>
inner_loop: <true|false>

## Progress Milestones
session_id: <session-id>
Report progress via team_msg at natural phase boundaries (context loaded -> core work done -> verification).
Report blockers immediately via team_msg type="blocker".
Report completion via team_msg type="task_complete" after final SendMessage.

Read role_spec file (@<skill_root>/roles/<role>/role.md) to load Phase 2-4 domain instructions.
Execute built-in Phase 1 (task discovery) -> role Phase 2-4 -> built-in Phase 5 (report).`
})

User Commands

CommandAction
check / statusView execution status graph
resume / continueAdvance to next step

Specs Reference

Session Directory

.workflow/.team/UIP-<slug>-<date>/
+-- .msg/
|   +-- messages.jsonl         # Team message bus
|   +-- meta.json              # Pipeline config + GC state
+-- scan/                      # Scanner output
|   +-- scan-report.md
+-- diagnosis/                 # Diagnostician output
|   +-- diagnosis-report.md
+-- optimization/              # Optimizer output
|   +-- fix-log.md
+-- verification/              # Verifier output
|   +-- verify-report.md
+-- evidence/                  # Screenshots (before/after)
|   +-- *.png
+-- wisdom/                    # Cross-task knowledge

Error Handling

ScenarioResolution
Unknown commandError with available command list
Role not foundError with role registry
Session corruptionAttempt recovery, fallback to manual
Fast-advance conflictCoordinator reconciles on next callback
Completion action failsDefault to Keep Active
GC loop stuck > 2 roundsEscalate to user: accept / retry / terminate