Your users of your apps almost certainly have different workflow needs for how they use your app. For example, the admin will certainly use the app different than a lower permissioned data entry person. And you may have different types of data entry people with different jobs who need to focus on different features of your app in different ways.
Here's a standard ticket I create so that the AI thinks about all the types of users and how they work and then designs the UX for each of their roles.
```text
Create a ticket: Think deeply of the target users and the roles of the
different types of users for this app. What are each type of user's
expectations for a UX? Design the UI to support the workflows of
each user role. There should not be just a generic, one-size fits
all UI. It's OK to have that, but the workflows need to be first
class citizens.
```
If you want to level up, here's a ChatGPT 5.2 improvement
(this is for an EXISTING app):
```text
Create a UX audit and refactor ticket for the current app.
Think deeply on this.
You already know the existing features, routes, components, and role
handling as implemented in the codebase. Do NOT redesign from
imagination. Work strictly from the current implementation.
Base all analysis on actual files, components, routes, role checks, and
permissions currently present. When proposing changes, reference specific
file paths and components.
1. Identify Existing Roles (From Code)
* Enumerate roles as defined in code/config.
* Show where each role is defined (file paths).
* Provide a permissions matrix per role.
* List which routes/screens/components are accessible per role.
* Note any implicit role assumptions baked into UI components.
2. Workflow Audit – Current State
For each role:
* Identify the top 5 real workflows currently supported.
* Provide exact click path (route + component names).
* Identify friction points in the current UI.
* Identify where UI is generic instead of role-optimized.
* Note duplicated effort or unnecessary navigation steps.
3. Navigation & Information Architecture Audit
* Document the current navigation structure (with file references).
* Identify which navigation items are global vs role-conditional.
* Highlight weak or confusing role separation.
* Identify redundant, mis-grouped, or buried features.
* Identify screens that serve multiple roles but should be split or specialized.
4. Refactor Proposal (Within Existing Capabilities)
* Propose role-specific dashboards (using existing components where possible).
* Suggest role-specific quick actions.
* Propose navigation regrouping.
* Suggest surfacing/hiding changes based on role.
* Explicitly mark any proposal that requires backend changes.
* Minimize code churn. Prefer restructuring over adding new systems.
For every proposed change:
* Reference impacted file(s).
* Describe scope of modification.
* Classify risk level (Low / Medium / High).
5. Screen-Level Improvements
Audit and propose improvements for:
* Empty states
* Loading states
* Error states
* Permission-restricted states
* High-friction forms
Reference exact components and files when discussing changes.
6. Verification Plan
Provide:
* Role-by-role manual test checklist
* Before vs after comparison summary
* Clear definition of what “workflow is first-class” means in measurable terms
* A regression risk list (what could break)
7. Prioritized Implementation Plan
* Phase 1: High-impact, low-risk improvements
* Phase 2: Structural refinements
* Phase 3: Polish and consistency
* Estimated relative effort per phase
Constraints:
* Do not invent new backend capabilities.
* Preserve all existing functionality.
* Do not remove features unless justified.
* Avoid cosmetic-only recommendations unless tied to workflow improvement.
* Stay grounded in actual code structure.
End with:
* A concise executive summary of the most important UX structural weaknesses in the current implementation.
```
Now, put this in a file and put that file in a place where you can re-use it in any app. I put mine in my Projects/Documentation/Prompts dir.
---
*This tip was written by a human, except the ChatGPT 5.2 improved prompt, as explained.*
Your apps should make UX Workflows Per Role 1st Class Citizens
By Mike
86 views
0