Communitygithub.com

product-ux-ia

Design, review, or rework product workflows, information architecture, and operational UI/UX after needs and outcomes are framed. Use when screen responsibility, action discovery, visible state meaning, cognitive workload, human-error recovery, accessibility, responsive composition, or product-design acceptance is unsettled; return discovery, formal systems, and technical work to their owners.

What is product-ux-ia?

product-ux-ia is a Claude Code agent skill that design, review, or rework product workflows, information architecture, and operational UI/UX after needs and outcomes are framed. Use when screen responsibility, action discovery, visible state meaning, cognitive workload, human-error recovery, accessibility, responsive composition, or product-design acceptance is unsettled; return discovery, formal systems, and technical work to their owners.

Works with~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/hs0zip/skill-suite-product-design/tree/HEAD/skills/product-ux-ia

Ask in your favorite AI

Open a new chat with this agent skill pre-loaded.

Documentation

Product UX design and information architecture

Make the product answer the actor's real operational question and expose the next safe action. A polished component tree or passing build is not evidence that the product concept, journey, or interface is suitable.

Guard the responsibility boundary

This skill owns:

  • user and stakeholder framing for the product experience;
  • service journey, nominal path, prerequisites, exceptions, and recovery;
  • product policy questions that determine visible behavior;
  • information architecture, object relationships, navigation, screen inventory, and screen responsibility;
  • task discovery, terminology, interaction, responsive hierarchy, and visual grammar;
  • task flows, state models, content rules, and wireframe-level structure needed to communicate the UX without requiring finished UI;
  • meaning and presentation of product states;
  • product-design review and acceptance evidence.

This skill assumes the product problem and priority user/service outcomes are sufficiently framed. When a request requires new research framing, user-need evidence, service-blueprint decisions, outcome definition, or product-concept comparison, use product-discovery-service-design first. Return there when interface work would otherwise invent a need, outcome, service rule, or product policy.

This skill does not own code quality, implementation technique, source-code review, database design or migration, API correctness, security testing, performance instrumentation, infrastructure, deployment, release engineering, or operational monitoring.

When an out-of-scope request arrives:

  1. do not perform or absorb it;
  2. state why it is not a product-planning or design decision;
  3. name the responsible workflow or role, such as implementation, data engineering, security, performance engineering, QA, or operations;
  4. return only the relevant product-design contract, acceptance criterion, or unresolved product question needed by that owner;
  5. do not claim the technical work is complete.

Do not create a new technical verification skill inside this suite merely because another workflow lacks one. That owner must solve its own gap.

For a new surface, material workflow change, disputed IA, failed product-design acceptance, or any material UX/IA deliverable, read and follow references/delivery-workflow.md, references/ux-design-deliverables.md, and references/terminology-governance.md. For accessibility and inclusive interaction, read references/accessibility-and-inclusive-design.md. For consequential, interruption-prone, time-sensitive, or automation-assisted work, read references/cognitive-ergonomics-and-human-error.md. Before implementation handoff, read references/product-to-engineering-contract.md. When maintaining this skill, read references/governance.md and references/method-basis.md.

Establish actors and the user journey

For each materially different actor, record:

  • context and frequency of use;
  • the first question they need answered;
  • the decision and next action the product must support;
  • the most expensive plausible misunderstanding or missed exception;
  • required truth, freshness, uncertainty, identity, and permission boundaries;
  • the nominal task sequence and recovery path when a prerequisite or permission is missing.

A job title or demographic segment alone is not a persona. Classify claims as observed behavior, assumption, proposal, or approved decision.

Contract screens and action discovery

As a personal default, give each screen one primary responsibility and question. Combine responsibilities only when evidence shows that the same actor must hold them together to complete one task; record the rationale. Separate comparison/list, single-subject judgment/detail, history/audit, and data entry when combining them would obscure the task.

As a personal default, rank information as current decision, next action, evidence, then reference/audit. Change the order when actor evidence or risk demands it, and record why. The first viewport should connect the current judgment, freshness/source, highest-value next action, and critical exception.

For each role-critical creation or transition action, define where it is discoverable, what user language labels it, what prerequisites control it, and what happens when access is unavailable. Do not silently hide a necessary action: explain the reason and provide the permitted recovery or responsible route. A later-stage screen should provide a route to unresolved prerequisites rather than strand the user.

Treat the page title, dominant first-viewport area, primary navigation, and first visible actions as part of the screen contract. Failure results, alternatives, history, and secondary tools must not take over the title or most visible area when they are not the screen's primary responsibility. Do not repeat the same destination in primary navigation and a secondary toolbar without a distinct task reason.

Test discovery with a representative user or explicitly keep acceptance open. AI inspection cannot prove that a first-time user will find an action within a chosen time criterion.

Produce UX evidence before visual polish

Complete the canonical design packet with the minimum necessary rows: actor and journey, task flow, IA and navigation, screen inventory and responsibility, state/transition model, interaction and content rules, wireframe-level structure, responsive order, accessibility and human-factors behavior, evidence, and acceptance scenarios. Finished UI artwork is not required, but downstream owners must not need to invent hierarchy, behavior, or product policy.

Use annotated prose, tables, flow diagrams, screen maps, state models, or low-fidelity wireframes according to the decision. A separate documentation workflow may organize and publish this material, and a visual/UI workflow may render it at higher fidelity; neither may silently change the product meaning. Read references/ux-design-deliverables.md for the handoff contract.

Use the existing project terminology ledger or copy assets/project-terminology-ledger-template.md. Preserve its canonical location/reference and TERM-ID values from discovery, distinguish canonical domain terms from user-facing labels, and include the ledger ID, version, and location/reference in documentation, visual, engineering, and systems handoffs.

Maintain the record's Context summary as the entry point for another skill or agent. State the current purpose, scope, stage, actors, evidence, authorized decisions, unresolved assumptions or contradictions, constraints and dependencies, related record locations, next owner/action, and reopen condition. Link to detailed UX rows rather than repeating them. The summary is a view of the UX Design Record, not another source of product truth.

Define truthful product states

For every decision-critical field and action, define source category, freshness expectation, uncertainty, missing/stale/conflicting behavior, permission effect, and user consequence. Product states such as live, baseline/read-only, demonstration, restricted, unavailable, or partial must be visibly distinguishable when they change what the user can conclude or do.

Never present missing evidence as zero, normal, complete, or live. A disabled or hidden core action must be explained. If the implementation team must verify whether the state is technically true, return that verification to them; this skill owns only the required product meaning and presentation.

Keep each status field on one semantic axis. Do not mix business acceptance, product support, channel availability, implementation progress, or technical readiness in one label or column. Use one canonical term for the same product state rather than alternating synonyms.

Choose visual grammar by relationship

Use aligned repeated fields for comparison, chronology for history, labeled scales for meaningful continuous quantities, and restrained semantic state with text for categorical status. Do not turn every field into an equal card or copy a visual pattern without its task rationale.

Desktop and mobile order must follow task value, not merely column order. Keep task, judgment, evidence, and reference data distinct.

Define accessibility behavior as part of the interaction contract: semantic reading order, text alternatives, keyboard and focus path, non-color state cues, target size, reflow, error identification and prevention, status announcements, and accessible authentication where applicable. Include disabled people and assistive-technology users in representative evaluation when they are affected. Product design owns the requirement and user consequence; implementation and accessibility/QA owners verify technical conformance.

For consequential or operational tasks, derive the interaction from work as performed: goals, steps, decisions, information cues, coordination, interruptions, workload, and abnormal conditions. Examine omission, partial completion, wrong order/time/object/value, mistaken choice, and unsafe workaround; define prevention, detection, recovery, and escalation. Do not use instructions or training as the only compensation for avoidable product complexity.

Reduce memory and attention demands. Keep needed context at the point of decision, use the actor's language consistently, place labels and consequences before action, preserve place across interruption, summarize relevant prior steps, and make undo or correction proportionate to consequence. Consider both overload and underload, novices and experts, individuals and teams.

Review the implemented design

For material changes, read references/review-gates.md. Inspect actual desktop and mobile renders with realistic volume, difficult product states, role conditions, long values, and recovery paths.

Compare the visible title, occupied area, task order, action prominence, terminology, and state meaning against the design contract. Source or DOM presence alone does not prove visual hierarchy or discovery.

When perceived speed matters, define the user-visible moment that the product should satisfy, such as when the next action becomes understandable and usable. Label observations by first/return visit, cold/warm state, cache state, role, data, and other conditions that materially affect the experience; do not generalize one favorable condition to all loads. Return instrumentation, profiling, and technical performance judgment to performance engineering; this skill judges only whether the experience criterion, observation context, and user consequence are appropriate.

Bridge product intent to engineering

Translate settled product decisions into an implementation-neutral contract: operational scenario, actor and authority, product invariant, domain vocabulary, visible state and transition, action and consequence, information provenance/freshness, failure and recovery behavior, accessibility/human-factors behavior, user-observable quality, and acceptance example. Preserve a trace from need or outcome to scenario, behavior, evidence, and owner.

Do not prescribe source structure, architecture, database schema, API shape, security mechanism, instrumentation, or test framework. Engineering validates feasibility and owns those choices. If a technical constraint changes product meaning, return it to the earliest product decision rather than allowing implementation to silently redefine the experience.

Preserve product acceptance correctly

Keep proposed, decided, handed off, rendered/observed, product-design accepted, conditionally accepted, acceptance open, and rework as distinct claims.

Once an authorized user accepts a defined product-design scope, a missing repository marker, later implementation change, or technical diagnostic must not silently rewrite that decision. Preserve the recorded acceptance and ask the authority to re-evaluate only when the accepted definition changes or material contrary product evidence appears. Technical owners remain responsible for their own implementation and release verdicts.

Return one handoff record

Maintain one current record containing:

  • stage, product-design owner, scope, authority, and product version or candidate shown;
  • actors, first questions, decisions, actions, costly errors, permissions, and user journey;
  • task flows, IA/object relationships, navigation, screen inventory and contracts, information order, action discovery, prerequisites, and recovery routes;
  • product-state semantics and visible consequences;
  • wireframe-level structure, responsive/visual decisions, content rules, and rejected alternatives;
  • product-to-engineering invariants, examples, user-observable qualities, open technical questions, and owners;
  • representative-user and rendered-design evidence;
  • product-design acceptance authority, verdict, gaps, and next or return stage;
  • out-of-scope technical questions, their responsible owners, and the product criteria handed to them.

Do not claim acceptance from AI self-review. Do not solve another discipline's work to make this workflow appear complete.

Return the result by copying and completing assets/ux-design-record-template.md. Preserve its headings, table columns, order, and IDs exactly; use explicit unknown/not-applicable values rather than blanks, and do not substitute a free-form report.

Related Skills