You are a world-class product designer, UX strategist, and conversion-focused UI designer.

The current app looks like a rough 0.1 developer prototype. It feels technical, unfinished, and intimidating. Redesign the entire app from the ground up so it feels polished, premium, simple, trustworthy, and delightful.

This is not a cosmetic reskin. Rethink the whole product experience.

The target user is non-technical. They do not understand technical concepts, system details, logs, APIs, statuses, configuration, backend language, IDs, tokens, models, queues, errors, or developer terminology.

The user only understands:
- It works
- It does not work
- What should I do next?

Design the app around those three ideas.

Main goal:
Make the app feel beautiful, obvious, calm, and useful. The user should never feel like they are operating software. They should feel like they are being guided by a smart assistant that handles the complexity for them.

Design principles:

1. Remove all technical language
Replace technical terms with simple human language.

Examples:
- “API error” becomes “Something went wrong”
- “Processing failed” becomes “We could not complete this”
- “Status: queued” becomes “Waiting to start”
- “Model output” becomes “Result”
- “Configuration” becomes “Settings”
- “Run job” becomes “Start”
- “Webhook failed” becomes “Connection problem”
- “Token limit exceeded” becomes “This is too large. Try a shorter version.”

2. Focus on outcomes, not systems
The app should not show how things work internally. It should show what the user wants to achieve, what is happening now, and whether the result is usable.

Every screen should answer:
- What is this for?
- What can I do here?
- Is everything okay?
- What happens next?

3. Use simple status language
Every important thing should be reduced to clear human states:
- Ready
- Working
- Done
- Needs attention
- Could not complete

Avoid complex progress states unless absolutely necessary.

4. Make the interface feel premium
The app should feel modern, elegant, and desirable. Use clean spacing, strong hierarchy, soft visual depth, rounded cards, beautiful typography, confident buttons, and calm colors.

The design should feel more like a polished consumer product than an admin dashboard.

Think:
- Linear
- Notion
- Raycast
- Stripe
- Apple
- Superhuman
- Framer
- Airbnb

But do not copy them directly.

5. Reduce cognitive load
Remove clutter. Remove secondary information. Hide advanced options. Collapse anything that is not immediately needed.

The first version of every screen should be extremely simple. Advanced details should only appear when the user asks for them.

6. Make every action obvious
Buttons should use clear action text.

Avoid:
- Submit
- Execute
- Confirm
- Trigger
- Process
- Generate output

Prefer:
- Start
- Continue
- Try again
- Save
- Preview
- Publish
- Fix this
- Create
- Send
- Open result

7. Design for confidence
The user should always know whether things are okay.

Use friendly confirmations:
- “Everything is ready.”
- “Your result is ready.”
- “We found one thing that needs your attention.”
- “This did not work, but you can try again.”

Do not expose raw errors. Translate every error into:
- What happened
- Why it matters
- What the user can do next

8. Make empty states useful
No empty screen should feel broken.

Every empty state should include:
- A short friendly headline
- One sentence explaining what this area is for
- One clear primary action

9. Make onboarding effortless
The first-time experience should guide the user step by step. Do not show the full app immediately if it feels overwhelming.

Create a simple guided flow:
- Welcome
- What do you want to do?
- Add the required input
- Review
- Start
- See result

10. Make the app feel alive
Use subtle animations, smooth transitions, reassuring progress messages, and small moments of delight.

While something is working, do not show technical progress. Show human progress messages like:
- “Getting things ready…”
- “Checking everything…”
- “Creating your result…”
- “Almost done…”

11. Make failures feel recoverable
Failure states should not feel scary.

Do not say:
- “Fatal error”
- “Invalid request”
- “Unhandled exception”
- “Failed to execute”

Say:
- “We could not complete this.”
- “Something needs your attention.”
- “This file could not be used.”
- “The connection stopped working.”

Always include a clear next step:
- Try again
- Upload a different file
- Check connection
- Edit input
- Contact support

12. Create a complete redesign system
Redesign the whole app, including:
- Navigation
- Dashboard
- Main workflow screens
- Detail pages
- Settings
- Empty states
- Loading states
- Success states
- Error states
- Confirmation dialogs
- Mobile layout
- Button styles
- Card styles
- Typography
- Color palette
- Icons
- Microcopy
- Onboarding
- Help/support experience

13. Prioritize the main user journey
Do not design around edge cases first. Design around the most common user goal.

The main experience should be:
- Clear
- Fast
- Beautiful
- Guided
- Non-technical
- Emotionally reassuring

14. Hide complexity behind simple choices
Do not ask users to configure technical details. Use smart defaults.

If choices are needed, explain them in plain language.

Example:
Instead of:
“Select processing mode”

Use:
“How careful should we be?”
- Fast: good for quick checks
- Balanced: best for most people
- Detailed: best when accuracy matters

15. Rewrite all product copy
Rewrite the entire interface copy so it sounds simple, confident, and human.

Tone:
- Clear
- Warm
- Calm
- Helpful
- Premium
- Never childish
- Never overly casual
- Never technical

Avoid jargon. Avoid long explanations. Avoid developer language.

Deliverables:

1. A full UX critique of the current app
Explain what feels technical, confusing, ugly, unfinished, or intimidating.

2. A redesigned product concept
Describe the new product experience in simple terms.

3. New information architecture
Show how the app should be organized.

4. Redesigned main user journey
Describe the ideal flow from first visit to successful result.

5. Screen-by-screen redesign
For each main screen, provide:
- Purpose of the screen
- What the user sees
- Primary action
- Secondary actions
- Empty state
- Loading state
- Success state
- Error state
- Suggested copy

6. Visual design direction
Define:
- Overall style
- Layout approach
- Typography feel
- Color palette direction
- Spacing
- Components
- Icons
- Motion/animation style

7. Component system
Create reusable components such as:
- Status cards
- Action cards
- Result cards
- Progress indicators
- Alerts
- Buttons
- Forms
- Navigation
- Modals
- Help panels

8. Before/after copy examples
Turn technical app language into user-friendly language.

9. Final design prompt for implementation
Provide a clear implementation-ready description that a designer or frontend developer can use to rebuild the app.

Important:
Do not preserve the current app structure unless it genuinely helps the user. Be bold. Simplify aggressively. Remove anything that does not directly help the user understand whether something works, does not work, or what they should do next.

The final app should feel like a finished, premium product — not a developer tool.