4,500+ servers built on MCP Fusion
Vinkius

UI/UX Excellence Prover MCP. Enforce 2026 UI standards: Motion, States, Accessibility.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

UI/UX Excellence Prover MCP on Cursor AI Code Editor MCP Client UI/UX Excellence Prover MCP on Claude Desktop App MCP Integration UI/UX Excellence Prover MCP on OpenAI Agents SDK MCP Compatible UI/UX Excellence Prover MCP on Visual Studio Code MCP Extension Client UI/UX Excellence Prover MCP on GitHub Copilot AI Agent MCP Integration UI/UX Excellence Prover MCP on Google Gemini AI MCP Integration UI/UX Excellence Prover MCP on Lovable AI Development MCP Client UI/UX Excellence Prover MCP on Mistral AI Agents MCP Compatible UI/UX Excellence Prover MCP on Amazon AWS Bedrock MCP Support

Just plug in your AI agents and start using Vinkius.

UI/UX Excellence Prover enforces 2026-era design standards on generated interfaces. This tool checks for semantic spatial hierarchy, spring physics motion systems, mandatory 8-state microinteractions, and WCAG AAA accessibility compliance.

It flags everything from arbitrary padding to dark patterns, giving your AI client a critical review that goes beyond basic functionality.

What your AI agents can do

Validate uiux excellence

Validates any UI/UX design against six pillars: spatial hierarchy, spring motion physics, 8 element states, 8px rhythm, WCAG AAA accessibility, and zero dark patterns.

Check Spatial Structure

Validates component depth and materiality using semantic elevation levels (0-5) and Liquid Glass principles.

Analyze Motion Physics

Verifies that animations use spring physics models (stiffness/damping) at 60fps, ensuring motion is purposeful rather than decorative.

Verify Element States

Confirms interactive components include all necessary states: idle, hover, active, focus, disabled, loading, success, and error.

Enforce Grid and Spacing

Checks the entire layout against an 8px modular grid system and consistent typographic scaling.

Audit Accessibility Compliance

Tests for WCAG 2.2 AAA compliance, including proper aria roles and keyboard focus trap implementation.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

UI/UX Excellence Prover MCP Server: 1 Tool

Use the single available tool to run a deep architectural audit on any UI design, validating its compliance with modern UX standards.

validate019e58cd

validate uiux excellence

Validates any UI/UX design against six pillars: spatial hierarchy, spring motion physics, 8 element states, 8px rhythm, WCAG AAA accessibility, and zero dark patterns.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

  • Import from OpenAPI, Swagger, or YAML specs
  • Create Agent Skills with progressive disclosure
  • Deploy to edge with MCPFusion framework
  • Built in DLP, auth, and compliance on every call
  • Real time usage dashboard and cost metering
  • Publish to catalog or keep private
Start building

Make Your AI Do More

Start with UI/UX Excellence Prover, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.

  • Use this MCP plus 4,700+ others, all in one place
  • Add new capabilities to your AI anytime you want
  • Every connection is secured and compliant automatically
  • Track usage and costs across all your servers
  • Works with Claude, ChatGPT, Cursor, and more
  • New servers added to the catalog every week

What you can do with this MCP connector

Look, your AI client can spit out a bunch of code fast. But speed ain't quality. The interfaces it builds often fall way short of what senior designers use every day—they look cheap, they feel clunky, and they fail basic usability checks.

That’s where the validate_uiux_excellence tool comes in. It doesn't just glance at your design; it forces your AI client to run everything through six rigorous industry pillars. You get a critical review that goes way deeper than just making sure buttons work. It finds things like weird shadows, confusing depth, or motion that don’t mean anything.

Spatial Structure and Depth: This tool validates component placement by checking its semantic elevation level—you'll see it uses a system from 0 to 5 to communicate depth, not just throwing random box-shadow values on everything. It enforces principles like Liquid Glass materiality, making sure the layout communicates hierarchy through structure itself.

Motion Physics and Interaction: The tool checks your animations hard. It verifies that any motion uses proper spring physics models—specifically checking for stiffness and damping ratios at a consistent 60 frames per second (fps). If the animation doesn't serve a clear function, like guiding the user or confirming an action, it fails.

You won't get decorative wobble; you'll get purposeful movement.

Element States and Lifecycle: Every interactive component must pass through a full lifecycle test. This includes checking for eight mandatory states: idle, hover (when the mouse’s over it), active (when you press it down), focus (for keyboard navigation), disabled (if it can't be used yet), loading, success, and error. It won't let you launch anything without all those pieces.

Grid System and Spacing: The tool enforces structure across the whole layout. You’ll see it checks against a strict 8px modular grid system for alignment and consistently scales your typography. This means no arbitrary padding—everything has to fit the established rhythm, or it gets flagged.

Accessibility Compliance (WCAG AAA): It runs comprehensive tests against WCAG 2.2 AAA standards. These aren't just suggestions; they are hard requirements. The tool ensures proper aria roles for screen readers and implements keyboard focus traps so that when a user navigates with the Tab key, their focus never gets lost in the design.

This is non-negotiable.

Dark Pattern Auditing: Finally, it actively hunts down dark patterns—those sneaky tricks like infinite scroll mechanisms or fake urgency timers. It forces intentional friction and transparency into your UI, making sure the user experience isn't misleading or manipulative.

When you use this tool, you get a complete architectural review that ensures your output doesn't just function but looks like it belongs in a real product at the top tier of the industry. It handles everything from semantic depth levels and spring physics models to WCAG AAA compliance and eight-state microinteractions.

How UI/UX Excellence Prover MCP Works

  1. 1 Feed the tool your design wireframe or code snippet (e.g., a component structure).
  2. 2 The validate_uiux_excellence tool runs its full audit across six pillars, checking for deviations from 2026 standards.
  3. 3 You receive a verdict: DESIGN_PROVEN (it passed) or FLAT_DECORATION/DARK_PATTERN_DETECTED (it failed), with specific failure points listed.

The bottom line is that this tool forces your AI client to think like a senior design architect, catching the structural flaws most generators miss.

Who Is UI/UX Excellence Prover MCP For?

Product architects and UI engineers who know that 'it works' isn't good enough. This server is for people tired of building beautiful-looking but technically flawed interfaces—the kind where the shadows are decorative, not communicative.

UI Engineer

Uses this tool to write validation logic that enforces component state changes and 8px grid adherence before committing code.

Product Designer

Inputs mockups into the server to confirm they meet WCAG AAA standards and avoid visual pitfalls like random spacing or auto-playing videos.

Frontend Architect

Runs full system checks on new features, ensuring motion physics are applied correctly across all components instead of relying on simple CSS transitions.

What Changes When You Connect

  • Stops Flat Design: The tool forces proper spatial hierarchy (Elevation 0-5) and Liquid Glass materiality. You stop using shadows just for decoration; they now communicate depth.
  • Guarantees Interaction Polish: It requires every button and component to define all 8 states (idle, hover, active, focus, etc.). Your agent won't ship a button with only a color change on hover.
  • Enforces Smooth Motion Physics: Instead of simple CSS ease-in-out, the tool mandates spring physics (stiffness/damping) at 60fps. Animations now feel deliberate, not random.
  • Builds Truly Accessible Systems: It runs WCAG 2.2 AAA checks and handles prefers-reduced-motion fallbacks automatically. Your UI works for keyboard users and screen readers.
  • Eliminates Cognitive Traps: The Prover actively scans for dark patterns—infinite scroll, auto-play videos, fake urgency. You build systems that respect user agency.

Real-World Use Cases

01

Building a complex dashboard UI

The architect needs to ensure the new KPI cards don't just look good. They run validate_uiux_excellence which instantly catches that the elevation change on hover is too simple, forcing them to implement spring physics and proper 8-state microinteractions.

02

Integrating a settings panel

A developer adds a new section for user preferences. The server flags inconsistent spacing (rhythm collapse) and warns that the modal doesn't have focus traps or clear keyboard navigation, forcing compliance with WCAG AAA.

03

Designing an onboarding flow

The team wants to use a particle background video. The tool immediately flags this as 'decorative noise without communicative purpose,' preventing the adoption of a dark pattern and guiding them toward intentional, guided motion.

04

Refining checkout button states

Before release, validate_uiux_excellence checks the primary CTA. It confirms that when the user clicks (active press) and if an error occurs (error state), the button behaves according to all 8 required microstates.

The Tradeoffs

Using random shadows/gradients

The team adds a gradient background and uses box-shadow everywhere to make things look 'premium.' The result looks messy, lacks depth logic, and fails the spatial hierarchy check.

Run validate_uiux_excellence. It forces you to define elevation 0-5 using semantic roles instead of relying on purely decorative CSS effects.

Implementing single-action buttons

A developer builds a 'Submit' button that only changes color when hovered. When clicked, nothing happens until the API returns data.

Use validate_uiux_excellence to ensure the component has all 8 states: idle/hover/active/focus/disabled/loading/success/error.

Using infinite scroll feeds

The team builds a news feed that loads more content automatically as you scroll, trapping user attention and making it hard to share or bookmark specific points.

Let the server check for dark patterns. It forces you to switch to paginated data tables or implement an explicit 'Load More' button.

When It Fits, When It Doesn't

Use this Prover if your goal is engineering fidelity: Does it pass WCAG 2.2 AAA? Is motion physics used purposefully? Are all component states accounted for? If the answer is yes, use this tool. Don't use it if you just need to generate any visual mockup; those are too basic. If your core problem is simply fetching or displaying static data (e.g., retrieving a user list), you don't need this server—you need a standard data retrieval MCP server instead.

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by UI/UX Excellence Prover. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

How we secure it →

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This server provides 1 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.

Available Capabilities

validate_uiux_excellence

Bad UI design isn't about bad taste; it's about broken logic.

Most AI-generated interfaces are functionally fine, but they fail the stress test. You end up with random spacing (rhythm collapse), buttons that only change color on hover, and shadows used purely for decoration instead of showing depth. It looks like a prototype, not a product.

With `validate_uiux_excellence`, you run an audit that forces 2026 standards. The tool doesn't just say 'fix this'; it tells you *why*—maybe the elevation needs to be semantic (0-5), or maybe the animation needs spring physics, not a simple ease-in-out curve. You get actionable architectural critique.

UI/UX Excellence Prover MCP Server: Build for Intentional Experience

Manual design reviews take hours and are subjective. Finding inconsistencies in spacing, missing accessibility roles, or identifying a dark pattern is a huge time sink that often gets missed until QA.

This server runs the full audit programmatically. It's instant, repeatable, and non-negotiable. You can hardwire these six pillars of excellence into your agent pipelines—it just works.

Common Questions About UI/UX Excellence Prover MCP

How does validate_uiux_excellence handle motion? +

It enforces spring physics (stiffness/damping) over simple CSS transitions. It verifies that movement only serves to explain, guide, or confirm an action, preventing decorative 'fluff' animations.

Does UI/UX Excellence Prover check for accessibility? +

Yes. The tool runs checks against WCAG 2.2 AAA standards. It specifically audits keyboard focus traps and ensures proper handling of prefers-reduced-motion settings.

What is the difference between this and a standard design checker? +

A standard checker looks for basic rules. The Prover checks architectural patterns, like ensuring all interactive elements have 8 defined states (idle through error), which goes far beyond simple visual compliance.

Can I use validate_uiux_excellence on existing code? +

Yes. You feed it your component structure or code snippet, and the tool provides a technical verdict listing exactly where spatial hierarchy fails or where dark patterns are detected.

What format should I provide when using validate_uiux_excellence? +

Focus on describing components or providing isolated code snippets for best results. The tool analyzes design decisions, so detailed context about the intended user flow helps it check all six pillars.

Are there any rate limits when I run validate_uiux_excellence? +

Vinkius manages usage rates, and specific throttling details are listed in the documentation. Since this tool is for iterative design, repeated validation across multiple components is expected.

Can I integrate validate_uiux_excellence into a CI/CD pipeline? +

Yes. The MCP standard allows you to call validate_uiux_excellence via API endpoints. This lets you enforce design compliance automatically before merging code.

If my prompt isn't about a user interface, will validate_uiux_excellence still give feedback? +

The tool is specialized for UI/UX patterns. If the input falls outside visual or interactive design scope, it returns an error stating that the content is unrelated to its defined pillars.

Does it generate UI designs or code? +

No. The agent designs or codes the interface. The tool VALIDATES that it meets 2026-era standards across six pillars: spatial hierarchy, spring motion, 8-state microinteractions, 8px rhythm, WCAG 2.2 AAA neuro-inclusive accessibility, and Calm UI principles. It coaches — not generates.

Why 8 states per interactive element? +

Because a button without feedback is a dead rectangle. The 8 states (idle, hover, active, focus-visible, disabled, loading, success, error) cover every moment of interaction. Each state uses spring physics for natural transitions. Without all 8, users cannot perceive affordance, progress, or outcome.

What is Calm UI and why does it matter? +

Calm UI is the 2026 shift from 'time on page' to 'time well spent'. It rejects dark patterns: infinite scroll without end states, auto-play media, fake urgency, hidden opt-outs. It implements intentional friction for destructive actions, progressive disclosure, and natural stopping points. Respect > engagement.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 1 tools

We've already built the connector for UI/UX Excellence Prover. Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 1 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.