OpenParable
Skip to content
← Back to skills

Team Uidesign

Design
team-uidesign

Team Uidesign 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 design team. Research -> design tokens -> audit -> implementation. Uses team-worker agent architecture with roles/ for domain logic. Coordinator orchestrates dual-track pipeline with GC loops and sync points. Triggers on "team ui design", "ui design team".

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-uidesign/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/team-uidesign, 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 Design

Systematic UI design pipeline: research -> design tokens -> review -> implementation. 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-uidesign", 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]
          researcher  designer  reviewer  implementer

Role Registry

RolePathPrefixInner Loop
coordinatorroles/coordinator/role.md——
researcherroles/researcher/role.mdRESEARCH-*false
designerroles/designer/role.mdDESIGN-*false
reviewerroles/reviewer/role.mdAUDIT-*false
implementerroles/implementer/role.mdBUILD-*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. Wiki knowledge: maestro search "UI design tokens audit" --json — top 5 entries as prior context
  4. 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: UDS
  • Session path: .workflow/.team/UDS-<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: "uidesign",
  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: uidesign
requirement: <task-description>
inner_loop: 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/UDS-<slug>-<date>/
├── .msg/
│   ├── messages.jsonl         # Team message bus
│   └── meta.json              # Pipeline config + GC state
├── research/                  # Researcher output
│   ├── design-system-analysis.json
│   ├── component-inventory.json
│   ├── accessibility-audit.json
│   ├── design-intelligence.json
│   └── visual-quality-baseline.json
├── design/                    # Designer output
│   ├── design-tokens.json
│   ├── component-specs/
│   └── layout-specs/
├── audit/                     # Reviewer output
│   └── audit-*.md
├── build/                     # Implementer output
│   ├── token-files/
│   └── component-files/
└── 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