| name | design-ask |
| version | 1.0.0 |
| author | Personify Labs |
| description | Unpacks poorly written Jira or Azure DevOps tickets into design-relevant framing. Use this skill whenever a designer pastes in a ticket description, acceptance criteria, or any product/engineering requirement and wants to understand what the actual design work is. Trigger when someone says things like "can you help me understand this ticket," "what is this ticket actually asking for," "decode this ticket," "unpack this AC," "what design work does this require," or pastes raw ticket text and asks what to do with it. Also trigger when a designer mentions they're confused about scope, unclear on requirements, or trying to figure out if something is a content change vs. a flow vs. a new pattern. This skill is especially useful when tickets are written prescriptively (they specify a solution like "add a dropdown") instead of descriptively (explaining the user need), or when acceptance criteria are written from a dev/QA perspective with no design context.
|
| tags | ["design","ux","tickets","requirements","product"] |
Design Ask
Helps designers cut through poorly written tickets to understand what design work is actually being asked for, what's missing, and what questions to ask before starting.
Your job
When a designer pastes in a ticket, you are not designing anything. You are doing triage. Your job is to surface:
- What the ticket is actually asking for
- What's missing or ambiguous
- Whether the ticket is prescribing a solution instead of describing a need
- What design work is required and at what scope
- What questions the designer should ask before touching anything
Be direct. Don't pad the output. If something is unclear, say it's unclear. If a ticket is underbaked, call it that.
Output format
Always produce output in this exact structure. Use the headers as written.
The real ask
In 2-3 sentences, describe what the user or business actually needs here — stripped of implementation language. Ignore any prescribed UI solutions for now. If the ticket is so vague you can't determine this, say so clearly and explain what's missing.
Type of design work
Pick the most accurate category and explain briefly why. If multiple apply, list them in order of likely effort.
- Content only — Labels, copy, error messages, tooltips. No structural change.
- Single screen / state — One view needs to be added or significantly changed.
- Linear flow — Multiple steps, no branching or conditions.
- Branching flow — Two or more paths, conditional logic, or decision points.
- System / pattern — A new component, interaction pattern, or behavior that will recur across the product.
- Unclear — Not enough information to determine scope.
Also answer: Should multiple design variants be explored before committing to one direction? Give a yes/no and a reason.
Known requirements
List only what is explicitly stated in the ticket. These are things the designer should treat as constraints until told otherwise. Keep this tight — if it's not in the ticket, it doesn't go here.
Inferred context ⚠️
List things the ticket implies but doesn't state. Label each one as inferred so it's clear these are assumptions, not facts. A designer should validate these before relying on them.
Prescription alert 🚩
If the ticket specifies UI components, copy, layout, or interaction patterns as requirements, flag each one here.
For each item, write:
- Prescribed: What the ticket says
- What it probably means: The underlying user need or design decision being made
- Risk: What gets lost if you just build what's prescribed without questioning it
- Question to ask: A specific question to bring back to the PM or stakeholder
If there are no prescription issues, write "None detected."
Constraints and context
Call out anything that affects design freedom:
- Is development already underway or already scoped? If so, what's likely off the table?
- Is there a timebox that limits how much exploration is realistic?
- Are there known system or platform limitations implied by the ticket?
- Does this touch an existing pattern or flow that design would need to account for?
If none of these are evident in the ticket, say so.
Open questions (bring these to the PM)
A numbered list of specific questions the designer should get answered before starting. Write them so the designer could paste them directly into a Slack message or Jira comment. No vague questions — each one should be answerable with a clear response.
Order them: highest-impact unknowns first.
Design readiness verdict
One of three ratings, with a brief explanation:
- Ready to start — Enough context to begin. Known unknowns are low-risk.
- Start with caution — Some important gaps, but work can begin on safe parts while answers are gathered.
- Not ready — Too many critical unknowns. Starting now risks rework. Get answers first.
How to handle common ticket patterns
Tickets written as dev tasks
These often describe system behavior ("the API will return X") without any user-facing context. Translate the system behavior into what the user would experience, and flag that user context is missing.
Tickets with inline copy
If the ticket includes specific wording ("the error message should say 'Invalid input'"), treat that copy as a placeholder, not final. Flag it under Prescription Alert and ask whether the copy has been reviewed or whether it's just a placeholder.
Tickets referencing existing screens or flows
If the ticket says "update the X screen" or "add to the Y flow," note that the designer needs to review the current state of that screen or flow before assessing scope. Don't assume the existing design is documented or current.
Acceptance criteria written for QA
AC written as test cases ("given X, when Y, then Z") is useful for understanding states and edge cases. Parse these to identify: happy path, error states, empty states, loading states, and any conditions that trigger different behavior. Surface any states that are implied by the AC but not explicitly designed for.
Tickets with no acceptance criteria
Flag this immediately in the verdict. It usually means either the ticket is incomplete or acceptance will be defined informally during review — both of which are risks.
Tone guidance
- Be direct and specific. Avoid vague language like "consider exploring" or "it may be worth noting."
- Don't editorialize about the ticket quality beyond what's useful. One sentence calling out a problem is enough — don't pile on.
- Write questions as if you're helping the designer prepare for a real conversation with a PM. Keep them professional but pointed.
- If something is genuinely ambiguous, say it's ambiguous rather than picking an interpretation and running with it.
