mcp-uimax
Runs full Google Lighthouse audits to provide real-time scores and detailed reports for performance, accessibility, best practices, and SEO, including fix instructions for identified issues.
UIMax MCP
Turns Claude Code into a frontend expert that reviews and fixes your UI automatically.
One command — "review my UI at localhost:3000" — and it:
Sees your app — captures a real screenshot via Puppeteer
Audits accessibility — runs axe-core for WCAG 2.1 violations
Runs Lighthouse — real Google Lighthouse scores (Performance, Accessibility, Best Practices, SEO)
Measures performance — captures Core Web Vitals (FCP, LCP, CLS, TBT)
Audits SEO — 18 checks: meta tags, Open Graph, Twitter cards, structured data, heading hierarchy, canonical URLs
Scans your code — AST-based analysis for 25+ anti-patterns across accessibility, design, and code quality
Grades everything — per-section Report Card with letter grades (A+ through F) for Accessibility, Performance, Best Practices, SEO, and Code Quality
Generates an expert review — Claude acts as a senior frontend engineer with a baked-in review methodology
Implements the fixes — edits your actual code files, starting from critical issues down
Tracks everything — auto-saves review history so you can see progress over time
Works on any URL — localhost, staging, production. Any site your machine can reach.
Free for all Claude Code users (Pro plan and above). No API keys. No extra costs. Just install and go.
claude mcp add uimax -- npx -y uimax-mcpQuick Start
Install as MCP Server (for Claude Code)
# Add to Claude Code — that's it, no API keys needed
claude mcp add uimax -- npx -y uimax-mcpThat's it. Now in any Claude Code conversation:
You: Review the UI at http://localhost:3000, source code is in ./src
Claude Code calls review_ui ->
1. Captures screenshot of your running app
2. Runs axe-core accessibility audit
3. Runs Google Lighthouse (Performance, A11y, Best Practices, SEO)
4. Measures Core Web Vitals
5. Runs dedicated SEO audit (18 checks)
6. Scans source code with AST-based analysis
7. Generates per-section Report Card (A+ through F letter grades)
8. Returns screenshot + all data + expert review methodology
9. Claude Code generates expert review (using YOUR Pro plan -- $0 extra)
10. Claude Code implements every fix automatically
11. Review saved to .uimax-reviews.json for trackingInstall Globally
npm install -g uimax-mcpRelated MCP server: LightScout MCP
Tools (37)
Review Pipeline
Tool | Description |
| The main tool. Full automated pipeline: screenshot + Lighthouse + axe-core + performance + SEO + code analysis + Report Card (A+-F letter grades) + expert review methodology. Auto-saves to review history. |
| New in v0.9.0. Re-run the full audit after applying fixes. Compares against the previous review and shows a before/after Report Card with grade transitions, resolved issue count, and verdict (improved/regressed/mixed). Closes the review-fix-verify loop. |
| New in v0.9.0. Competitive benchmarking — audit two URLs side-by-side. Returns screenshots of both sites plus a comparison Report Card with grades for Accessibility, Performance, SEO, and weighted Overall score. |
| Fast design-only review. Screenshot + focused design methodology. No code analysis or performance audit. |
| Generate a standalone HTML report with everything embedded. Now includes Report Card grade cards and SEO section. Dark themed, zero dependencies. Share with your team. |
Screenshots & Visual
Tool | Description |
| Capture a high-resolution PNG screenshot of any URL. |
| Screenshots at mobile (375px), tablet (768px), and desktop (1440px) viewports. |
| Compare light mode vs dark mode (emulated). Returns both screenshots + difference percentage. |
| Pixel-level diff using |
| AI-powered visual comparison. Captures before/after + pixel diff, returns structured methodology for Claude to evaluate whether changes match the intended design request. |
Lighthouse, Performance & SEO
Tool | Description |
| Full Google Lighthouse audit — Performance, Accessibility, Best Practices, SEO scores + failing audits. |
| New in v0.8.0. Dedicated SEO audit checking 18 signals: meta title/description, heading hierarchy, Open Graph, Twitter cards, structured data (JSON-LD), canonical URLs, image alt text, viewport meta, lang attribute, and more. Weighted scoring by impact. |
| PWA readiness: installable, service worker, HTTPS, manifest, offline capability. |
| Security analysis: HTTPS, CSP, mixed content, vulnerable JS libraries, external links without |
| Find unused JavaScript and CSS with exact byte savings per resource. |
| Deep LCP analysis: what the element is, resource load time, render delay, TTFB, optimization suggestions. |
| Full resource breakdown by type, transfer sizes, request count, top 10 largest, render-blocking resources. |
| Core Web Vitals via Performance API: FCP, LCP, CLS, TBT, DOM node count, JS heap size. |
| axe-core WCAG 2.1 Level A & AA audit. Violations grouped by severity with fix instructions. |
Code Analysis
Tool | Description |
| AST-based analysis (TypeScript compiler API) for 25+ rules. Zero false positives on string literals. Falls back to regex for non-JS files. Configurable via |
Browser Interaction
Tool | Description |
| Navigate to a URL, wait for network idle. Returns page info + screenshot. |
| Click an element by CSS selector. Returns screenshot after click. |
| Type into input fields. Options: |
| Select a dropdown option by value. Returns screenshot after. |
| Scroll by pixel amount or to a specific element. Returns screenshot after. |
| Wait for an element to appear in the DOM. Returns tag name and text content. |
| Get element details: attributes, bounding box, computed styles, visibility. |
Debugging
Tool | Description |
| Capture all console messages (log, warn, error, info, debug) + uncaught exceptions during page load. |
| Capture all network requests with status, size, timing, resource type. Summary grouped by type. |
| Capture JS exceptions, unhandled rejections, and failed resource loads. |
Multi-Page
Tool | Description |
| Discover internal links from a URL and audit up to 10 pages — screenshot + axe-core + performance each. |
Baselines & Budgets
Tool | Description |
| Save current audit state to |
| Compare current state vs previous baseline. Shows improvements and regressions with letter grade transitions (e.g., "D -> B+ (+22)"). |
| Enforce performance budgets from |
Review History
Tool | Description |
| View past UIMax reviews for this project. Filter by URL, limit count. Now includes letter grades alongside scores. |
| Aggregate statistics: total reviews, score trends, most common issues, most problematic files. Includes Code Quality grades. |
| Compare two specific reviews — new issues, resolved issues, score changes with letter grade transitions. |
Every review is auto-saved. When you run
review_ui, the results are automatically persisted to.uimax-reviews.json. No manual save needed — just ask "show me my review history" anytime.
Report Card (A+ through F)
Every review_ui run now generates a per-section Report Card with letter grades on a 13-tier scale:
┌─────────────────────────────────────────────────────┐
│ REPORT CARD │
├──────────────────┬──────────┬───────┬───────────────┤
│ Section │ Score │ Grade │ Rating │
├──────────────────┼──────────┼───────┼───────────────┤
│ Accessibility │ 95 │ A │ Excellent │
│ Performance │ 72 │ C- │ Below Average │
│ Best Practices │ 88 │ B+ │ Very Good │
│ SEO │ 61 │ D- │ Very Weak │
│ Code Quality │ 83 │ B │ Good │
└──────────────────┴──────────┴───────┴───────────────┘Grades appear in:
review_uioutput — Report Card table at the top of every reviewexport_reportHTML — color-coded grade cards (green A -> red F)compare_to_baseline— grade transitions showing improvement (e.g.,D -> B+ (+22))get_review_history/get_review_stats/review_diff— grades alongside numeric scores for quick scanning
The grading scale: A+ (97+) > A (93+) > A- (90+) > B+ (87+) > B (83+) > B- (80+) > C+ (77+) > C (73+) > C- (70+) > D+ (67+) > D (63+) > D- (60+) > F (<60)
AST-Powered Code Analysis
The analyze_code tool uses the TypeScript compiler API for .ts/.tsx/.js/.jsx files — catching bugs that regex misses with zero false positives.
Rule | What AST catches that regex misses |
| Hooks inside nested if/for/while/ternary — proper scope traversal |
|
|
| Empty catch blocks — not fooled by comments |
|
|
|
|
|
|
| JSX |
Falls back to regex for file types that can't be AST-parsed and for rules without AST implementations (hardcoded colors, z-index, font sizes, etc.).
Configuration
Create a .uimaxrc.json in your project root to customize code analysis and performance budgets:
{
"rules": {
"console-log": "off",
"magic-number": "off",
"hardcoded-color": "warn",
"inline-style": "error"
},
"severity": {
"todo-fixme": "high"
},
"ignore": [
"node_modules",
"dist",
"*.test.*",
"*.spec.*"
],
"budgets": {
"lighthouse": {
"performance": 90,
"accessibility": 95,
"bestPractices": 90,
"seo": 90
},
"webVitals": {
"fcp": 1800,
"lcp": 2500,
"cls": 0.1,
"tbt": 300
},
"maxAccessibilityViolations": 0,
"maxCodeIssues": 10
}
}rules— Set any rule to"off","warn", or"error"severity— Override severity:"low","medium","high","critical"ignore— Additional glob patterns to exclude from analysisbudgets— Performance thresholds enforced by thecheck_budgetstool
UIMax searches for .uimaxrc.json in the target directory and up to 3 parent directories, so it works in monorepos.
Prompts
Expert review prompts that guide Claude's analysis:
Prompt | Use Case |
| Comprehensive review (design + UX + a11y + perf + code) |
| Responsive design review across viewports |
| Fast visual/UX feedback from a screenshot only |
| AI-powered before/after visual comparison |
Example Workflows
Full Review (the main workflow)
You: Review the UI at http://localhost:3000
Source code is in ./src
Claude: [Calls review_ui]
[Captures screenshot, runs Lighthouse + axe + perf + code scan]
[Generates 20+ findings with specific fixes]
[Implements every fix automatically]
[Auto-saves review to .uimax-reviews.json]Review Any Public Website
You: Review the UI at https://stripe.com
Claude: [Calls review_ui]
[Full audit of the live production site]
[Returns findings + recommendations]Track Progress Over Time
You: Show me my review history
Claude: [Calls get_review_history]
[Shows table of past reviews: dates, scores, issue counts]
You: Compare my last two reviews
Claude: [Calls review_diff]
[Shows what improved ✅, what regressed ❌, new issues, resolved issues]
You: What are my most common issues?
Claude: [Calls get_review_stats]
[Shows trends, most common issues, most problematic files]Interact with Your App
You: Navigate to localhost:3000, click the login button,
type "test@email.com" in the email field
Claude: [Calls navigate → click → type_text]
[Returns a screenshot after each action]
[Verifies each step visually]Deep Performance Analysis
You: Find unused code on https://myapp.com
Claude: [Calls unused_code]
[Lists every unused JS/CSS file with byte savings]
[Suggests what to tree-shake]
You: Why is my LCP slow?
Claude: [Calls lcp_optimization]
[Identifies the LCP element, breakdown of load time]
[Specific optimization suggestions]Verify Fixes (Close the Loop)
You: Review and fix my UI at localhost:3000
Claude: [Calls review_ui → finds 14 issues → implements fixes]
You: Now verify the fixes worked
Claude: [Calls verify_fixes]
[Re-runs full audit → compares to previous review]
Fix Verification — Before vs After
| Metric | Before | After | Change |
| Accessibility violations | 5 | 0 | ✅ -5 |
| Code findings | 9 | 2 | ✅ -7 |
| Total issues | 14 | 2 | ✅ -12 |
Verdict: ✅ IMPROVEDCompetitive Benchmarking
You: Compare my site vs stripe.com
Claude: [Calls compare_sites]
[Audits both URLs concurrently]
[Returns screenshots of both sites + comparison table]
| Category | myapp.com | stripe.com | Winner |
| Accessibility | C+ (78) | A (94) | ✅ stripe.com |
| Performance | B- (81) | A+ (98) | ✅ stripe.com |
| SEO | D (63) | A (93) | ✅ stripe.com |
| Overall | C (74) | A (95) | ✅ stripe.com |SEO Audit
You: Run an SEO audit on https://myapp.com
Claude: [Calls seo_audit]
[Checks 18 SEO signals: meta tags, Open Graph, structured data, etc.]
[Returns score, passing checks, and failed checks with fix recommendations]
[Weighted by impact: critical > high > medium > low]Debug Page Load Issues
You: What console errors does localhost:3000 produce?
Claude: [Calls capture_console]
[Returns all console messages + uncaught exceptions]
You: Show me all network requests on page load
Claude: [Calls capture_network]
[Returns every request: URL, status, size, timing]
[Summary grouped by resource type]Before/After Comparison
You: Compare localhost:3000 with localhost:3001
Claude: [Calls compare_screenshots]
[Pixel-level diff with red-highlighted changes]
[Reports exact pixel difference %]Semantic Visual Review
You: I changed the header to be sticky. Compare before and after.
Claude: [Calls semantic_compare with change description]
[Captures both states + pixel diff]
[Evaluates whether changes match the intent]
[Checks for visual regressions]Enforce Performance Budgets
You: Check if my site meets our performance budgets
Claude: [Calls check_budgets]
[Reads thresholds from .uimaxrc.json]
[Returns ✅ pass or ❌ fail for each metric]Generate Shareable Report
You: Export a full report of localhost:3000 to ./report.html
Claude: [Calls export_report]
[Generates standalone dark-themed HTML report]
[Open in any browser, share with team]Multi-Page Audit
You: Crawl localhost:3000 and audit all pages
Claude: [Calls crawl_and_review]
[Discovers internal links, audits up to 10 pages]
[Per-page: screenshot + accessibility + performance]What Claude Reviews
When using the full review_ui pipeline, Claude evaluates:
Category | What's Checked |
Visual Design | Layout, typography, color contrast, whitespace, shadows, icon consistency |
User Experience | Navigation, interaction states, loading/error/empty states, edge cases |
Accessibility | WCAG 2.1 AA, keyboard nav, screen reader compat, focus management |
Performance | Lighthouse scores, Core Web Vitals, render-blocking resources, bundle size |
SEO | Meta tags, Open Graph, Twitter cards, structured data, heading hierarchy, canonical URLs, image alt text |
Code Quality | Component architecture, CSS organization, error boundaries, TypeScript safety |
Security | HTTPS, CSP, vulnerable libraries, mixed content |
Report Card | Per-section letter grades (A+ through F) for Accessibility, Performance, Best Practices, SEO, Code Quality |
Creative | Modern UI patterns (Linear, Vercel, Raycast), micro-interactions, animations |
Code Analysis Rules
The analyze_code tool checks for 25+ rules across categories:
Rule | Severity | Category |
| High | Accessibility |
| High | Accessibility |
| High | Accessibility |
| High | Accessibility |
| Medium | Accessibility |
| Medium | Accessibility |
| High | Code Quality |
| High | Code Quality |
| High | Bug |
| Low | Code Quality |
| Low | Code Quality |
| Medium | Code Quality |
| Medium | Code Quality |
| Low | Code Quality |
| Medium | Code Quality |
| Low | Code Quality |
| Medium | Design |
| Low | Design |
| Medium | Design |
| Medium | Design |
| Medium | Performance |
| Medium | Performance |
| Medium | UX |
| Medium | UX |
| Medium/High | Code Quality |
| Medium/High | Code Quality |
All rules can be toggled via .uimaxrc.json.
Supported Frameworks
Auto-detected from package.json:
React / Next.js
Vue / Nuxt
Svelte / SvelteKit
Angular
Plain HTML/CSS/JS
Requirements
Node.js >= 18.0.0
Chrome/Chromium (uses your system Chrome — no extra download)
Claude Code (for MCP integration)
No API keys needed — runs entirely within Claude Code using your existing Pro plan
How It Works
+----------------------------------------------------------------------+
| Claude Code (your Pro plan) |
| |
| User: "Review my UI at localhost:3000 and fix everything" |
| | |
| v |
| +----------------------------------------------------------------+ |
| | UIMax MCP (37 tools) | |
| | | |
| | Screenshot -------> Puppeteer ----------> PNG Image | |
| | Accessibility ----> axe-core ------------> WCAG Violations | |
| | Lighthouse -------> Google LH ----------> Scores + Audits | |
| | Deep LH ----------> PWA/Security/LCP --> Granular Analysis | |
| | SEO Audit --------> 18 checks ----------> SEO Score | |
| | Performance ------> Perf API ----------> Web Vitals | |
| | Code Scan --------> TypeScript AST -----> Anti-patterns | |
| | Report Card ------> Grading Engine -----> A+ to F Grades | |
| | Browser ----------> Click/Type/Scroll --> Interaction | |
| | Debugging --------> Console/Network ----> Runtime Data | |
| | History ----------> .uimax-reviews.json > Progress Tracking | |
| | Expert Prompt ----> Baked-in methodology | |
| +----------------------------+-----------------------------------+ |
| | |
| v |
| Claude Code receives: screenshot + data + expert methodology |
| | |
| v |
| Claude acts as world-class frontend expert (FREE -- Pro plan) |
| Generates comprehensive review with exact fixes |
| | |
| v |
| Claude implements every fix in the codebase automatically |
| |
+----------------------------------------------------------------------+CI / GitHub Action
UIMax ships with a reusable GitHub Action that runs audits on every PR and posts a Report Card comment.
Quick Setup
Copy the example workflow to your project:
# .github/workflows/uimax-ci.yml
name: UIMax Review
on:
pull_request:
branches: [main]
jobs:
uimax-review:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: "20"
# Build and start your app
- run: npm ci && npm run build
- run: npm start &
- run: npx wait-on http://localhost:3000
# Run UIMax
- uses: prembobby39-gif/uimax-mcp/.github/actions/uimax-review@main
with:
url: http://localhost:3000
budget-accessibility: 90
budget-performance: 80
budget-seo: 80
max-violations: 0Action Inputs
Input | Description | Required | Default |
| URL to audit | Yes | — |
| Token for PR comments | No |
|
| Min performance score (0-100) | No | — |
| Min accessibility score (0-100) | No | — |
| Min SEO score (0-100) | No | — |
| Max allowed a11y violations | No | — |
| Fail if grades regress | No |
|
Action Outputs
Output | Description |
| Letter grade (A+ through F) |
| Letter grade |
| Letter grade |
| Accessibility violation count |
| Whether all budgets passed ( |
| Full markdown report |
The action updates existing UIMax comments on re-push (no duplicate comments).
See examples/uimax-ci.yml for a complete working example.
Development
# Clone
git clone https://github.com/prembobby39-gif/uimax-mcp.git
cd uimax-mcp
# Install
npm install
# Build
npm run build
# Run tests
npm test
# Run tests with coverage
npm run test:coverage
# Test locally with Claude Code
claude mcp add uimax-dev -- node /path/to/uimax-mcp/dist/index.jsContributing
Contributions welcome! Some ideas:
CSS specificity analyzer
Design token extraction
Framework-specific checks (Vue composition API, Svelte stores)
Visual regression with pixel-level diffing
Performance budgets (fail if scores drop below thresholds)
Browser interaction (click, type, scroll, navigate)
Console and network capture
Deep Lighthouse analysis (PWA, security, unused code, LCP, resources)
AI-powered semantic visual comparison
Review history tracking with auto-save
Dedicated SEO audit (18 checks, weighted scoring)
Per-section letter grades (A+ through F Report Card)
Verify fixes (before/after comparison with grade transitions)
Competitive benchmarking (side-by-side site comparison)
CI/CD integration (GitHub Action for automated review on PR)
Custom rule plugins (user-defined regex rules)
Figma design comparison (screenshot vs Figma mock)
Cross-browser testing (Firefox, WebKit via Playwright)
License
MIT
Available Tools
37 toolsaccessibility_auditA
Run an automated accessibility audit using axe-core. Checks for WCAG 2.1 Level A and AA violations, reporting issues by severity with specific fix instructions.
Inputs: url (required).
analyze_codeB
Analyze frontend source code for quality issues: accessibility anti-patterns, CSS problems, component complexity, design inconsistencies, and performance concerns.
Inputs: directory (required).
capture_consoleA
Capture all console messages (log, warn, error, info, debug) during page load. Navigates to the URL, listens for console output and uncaught exceptions, then returns structured results with message counts by level. Useful for debugging runtime issues, detecting warnings, and finding errors that only appear in the browser console.
Note: Console messages may contain sensitive data (tokens, user info, etc.) — the output is returned unfiltered.
This tool is FREE — runs entirely within Claude Code.
Inputs: url (required), waitMs.
capture_errorsA
Capture JavaScript errors, uncaught exceptions, unhandled promise rejections, and failed resource loads (images, scripts, stylesheets, fonts) during page load. Returns structured error list with error kind, message, and source location. Useful for finding runtime JS errors and broken resources that affect user experience.
This tool is FREE — runs entirely within Claude Code.
Inputs: url (required).
capture_networkA
Capture all network requests during page load with status codes, sizes, timing, and resource types. Provides a summary with total requests, failed requests, total transfer size, and breakdown by resource type. Useful for finding failed API calls, slow requests, large assets, and understanding page load behavior.
This tool is FREE — runs entirely within Claude Code.
Inputs: url (required), waitMs.
check_budgetsA
Check if the current site meets performance budgets defined in .uimaxrc.json. Runs fresh audits and compares results against budget thresholds for Lighthouse scores, Web Vitals, accessibility violations, and code issues. Returns pass/fail with details of any exceeded budgets.
Configure budgets in .uimaxrc.json under the "budgets" key: { "budgets": { "lighthouse": { "performance": 90, "accessibility": 95 }, "webVitals": { "lcp": 2500, "cls": 0.1 }, "maxAccessibilityViolations": 0 } }
This tool is FREE — runs entirely within Claude Code.
Inputs: url (required), codeDir.
check_dark_modeA
Detect whether a webpage supports dark mode. Captures two screenshots — one in light mode and one with prefers-color-scheme: dark emulated — then compares them. Returns both screenshots and a difference percentage. Great for checking if dark mode is properly implemented.
Inputs: url (required).
clickA
Click an element by CSS selector. Returns a screenshot after the click so you can visually verify the result. Supports standard CSS selectors. If the page hasn't been navigated yet, provide a URL to navigate first.
Inputs: selector (required), url, waitAfter.
compare_screenshotsA
Before/after visual comparison with pixel-level diffing. Captures screenshots of two URLs at the same viewport size, computes an accurate pixel-level difference using pixelmatch, and returns BOTH images plus a red-highlighted diff image showing exactly which pixels changed. Use this to verify UI changes, compare staging vs production, or check before/after states of a redesign.
Inputs: urlA (required), urlB (required), width, height.
compare_sitesA
Competitive benchmarking: audit two URLs side-by-side and produce a comparison Report Card. Runs accessibility (axe-core), performance (Core Web Vitals), and SEO audits on both sites concurrently. Returns screenshots of both sites plus a grade comparison table showing which site wins in each category.
Use this when the user wants to benchmark their site against a competitor, compare staging vs production, or evaluate two different sites.
This tool is FREE — runs entirely within Claude Code.
Inputs: urlA (required), urlB (required).
compare_to_baselineA
Compare the current audit state of a URL against its most recent saved baseline. Runs fresh audits, loads the previous baseline from .uimax-history.json, and shows what improved and what regressed. Use this after making changes to verify you improved the metrics you intended.
This tool is FREE — runs entirely within Claude Code.
Inputs: url (required), codeDir.
crawl_and_reviewA
Crawl multiple pages from a starting URL and run accessibility + performance audits on each. Discovers internal links from the start page, deduplicates them, and visits up to maxPages (default 5, max 10). Each page gets a screenshot, axe-core accessibility audit, and Performance API metrics. Does NOT run Lighthouse (too slow for multi-page). Use this to audit an entire site section quickly.
This tool is FREE — runs entirely within Claude Code.
Inputs: url (required), maxPages, codeDir.
export_reportA
Generate a standalone HTML report file with all audit findings embedded. Runs the full review pipeline (screenshot, accessibility, performance, code analysis) and outputs a beautiful, shareable HTML file with zero external dependencies.
Use this when the user wants a downloadable/shareable report of their UI review.
This tool is FREE — runs entirely within Claude Code.
Inputs: url (required), codeDirectory (required), outputPath.
get_elementA
Get detailed information about a DOM element: tag name, text content, all attributes, bounding box, and computed styles (color, font, background, display, visibility). Returns a screenshot so you can visually identify the element in context.
Inputs: selector (required), url.
get_review_historyA
View past UIMax reviews for this project. Shows when reviews were run, what scores were achieved, and how many issues were found. Use this to understand the project's frontend health over time.
This tool is FREE — runs entirely within Claude Code.
Inputs: codeDir, limit, url.
get_review_statsA
Get aggregate statistics across all UIMax reviews for this project. Shows total reviews, score trends, most common issues, and most problematic files.
This tool is FREE — runs entirely within Claude Code.
Inputs: codeDir.
lcp_optimizationA
Deep Largest Contentful Paint (LCP) analysis. Identifies the LCP element, measures TTFB, resource load time, and render delay. Provides specific optimization suggestions to improve LCP below the 2.5s threshold.
Inputs: url (required).
lighthouse_auditA
Run a full Lighthouse audit against a URL. Returns scores for Performance, Accessibility, Best Practices, and SEO (0-100), plus detailed audit findings for render-blocking resources, image optimization, unused code, and more. Heavier than performance_audit but provides industry-standard Lighthouse scores.
Inputs: url (required).
performance_auditB
Measure Core Web Vitals and performance metrics: FCP, LCP, CLS, TBT, load time, resource count, DOM size, and JS heap usage.
Inputs: url (required).
pwa_auditA
Check Progressive Web App readiness: installable manifest, service worker, HTTPS, offline capability, and more. Runs a full Lighthouse audit under the hood and extracts all PWA-related audit results with pass/fail for each requirement.
Inputs: url (required).
quick_reviewA
Quick design-only review. Captures a screenshot and returns it with a focused design review methodology. No code analysis, no performance audit — just visual/UX feedback. Great for rapid design iteration.
After receiving the screenshot, analyze it as a senior UI designer and provide 5-10 high-impact observations with specific fixes.
This tool is FREE — runs entirely within Claude Code.
Inputs: url (required).
resource_analysisB
Full resource breakdown of a page: total transfer size, breakdown by type (JS, CSS, images, fonts), number of requests, top 10 largest resources, and render-blocking resources. Helps identify what is making your page heavy.
Inputs: url (required).
responsive_screenshotsA
Capture screenshots at mobile (375px), tablet (768px), and desktop (1440px) viewports. Perfect for reviewing responsive design.
Inputs: url (required).
review_diffA
Compare two specific reviews to see what changed. Shows new issues, resolved issues, and score changes.
This tool is FREE — runs entirely within Claude Code.
Inputs: reviewIdA (required), reviewIdB (required), codeDir.
review_uiB
THE PRIMARY TOOL — Fully automated UI review pipeline. Captures a screenshot, runs accessibility/performance/code audits, then returns ALL data along with an expert frontend review methodology so you can generate a comprehensive review and implement fixes.
Use this when the user asks to "review my UI", "audit my frontend", or "find UI issues". After receiving the results, you MUST:
Study the screenshot carefully for visual/UX issues
Analyze the audit data following the expert methodology provided
Generate a comprehensive review with SPECIFIC fixes (exact CSS values, code changes)
Implement the fixes directly in the codebase
This tool is FREE — it runs entirely within Claude Code using the user's existing plan. No API keys needed.
Inputs: url (required), codeDirectory (required), width, height.
save_baselineA
Save the current audit state for a URL as a baseline snapshot. Runs screenshot, accessibility, performance, and Lighthouse audits, then saves the results to .uimax-history.json in the project directory. Use this to establish a baseline before making changes, so you can compare later.
This tool is FREE — runs entirely within Claude Code.
Inputs: url (required), codeDir.
screenshotA
Capture a screenshot of a webpage. Returns a PNG image that you can visually analyze for design issues, layout problems, and UI quality.
Inputs: url (required), width, height, fullPage, +1 more.
scrollA
Scroll the page by a pixel amount or to a specific element. Returns a screenshot after scrolling so you can visually verify the new viewport position.
Inputs: url, direction, amount, toSelector.
security_auditA
Check security posture via Lighthouse: HTTPS usage, mixed content, CSP headers, vulnerable JavaScript libraries, external links without noopener, and more. Returns pass/fail findings with severity levels.
Inputs: url (required).
select_optionA
Select an option from a dropdown () element by value. Returns a screenshot after selection so you can visually verify the result.
Inputs: selector (required), value (required), url.
semantic_compareA
AI-powered visual comparison. Captures before/after screenshots and provides a structured methodology for Claude to semantically evaluate whether UI changes match the intended design request. Goes beyond pixel diffing to understand intent.
Returns both screenshots as images, a pixel-level diff image, the difference percentage, and a detailed semantic methodology prompt. Claude's vision analyzes the screenshots to determine if the changes match what was requested, checking for regressions and unintended side effects.
This tool is FREE — it runs entirely within Claude Code using the user's existing plan. No API keys needed.
Inputs: urlBefore (required), urlAfter (required), changeDescription (required), width, +1 more.
seo_auditA
Run a comprehensive SEO audit. Checks 18 SEO signals including meta tags, heading hierarchy, Open Graph tags, Twitter cards, structured data (JSON-LD), canonical URLs, image alt text, and more. Returns a 0-100 score and specific recommendations for each failing check.
Use this when the user wants to check their page's SEO health, improve search engine visibility, or ensure proper social sharing metadata.
This tool is FREE — runs entirely within Claude Code.
Inputs: url (required).
type_textA
Type text into an input field or textarea by CSS selector. Returns a screenshot after typing so you can visually verify the result. Options to clear existing text first and press Enter after typing.
Inputs: selector (required), text (required), url, clearFirst, +1 more.
unused_codeA
Find unused JavaScript and CSS on a page. Runs Lighthouse and extracts the unused-javascript and unused-css-rules audits, showing each resource with total bytes, unused bytes, and potential savings. Great for reducing bundle size.
Inputs: url (required).
verify_fixesA
Re-run the full audit pipeline after fixes are applied and compare against the original review. Shows a before/after Report Card with grade transitions, resolved issues count, and remaining issues. Closes the review-fix-verify loop.
Use this AFTER implementing fixes from a review_ui run. Pass the same URL and code directory. The tool re-audits everything and shows what improved.
This tool is FREE — runs entirely within Claude Code.
Inputs: url (required), codeDirectory (required), width, height.
wait_forA
Wait for an element to appear in the DOM. Returns the element's tag name and text content when found. Use this to wait for dynamic content to load before interacting with it.
Inputs: selector (required), url, timeout, visible.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 37 tools
Many tools have overlapping purposes (e.g., multiple performance audits, multiple comparison tools, and a 'primary' review tool that subsumes many others). Agents will struggle to choose the correct tool due to redundant functionality and unclear boundaries.
Most tools follow a verb_noun pattern (e.g., capture_console, check_budgets), but some deviate (lcp_optimization, responsive_screenshots). Overall, the naming is readable and predictable, with only minor inconsistencies.
With 37 tools, the server is overly bloated for its domain. Many tools are highly specific (e.g., check_dark_mode) and could be merged. This volume increases cognitive load and reduces efficiency.
The tool set covers nearly all aspects of UI auditing: accessibility, performance, SEO, visual comparison, interaction testing, and reporting. Minor gaps exist (e.g., no dedicated mobile viewport testing beyond responsive screenshots), but overall it is comprehensive.
Maintenance
Related MCP Connectors
Compare Figma designs against live websites and get visual + content QA reports, from inside Claude.
Live SEO workflow tools for Claude Code, Codex, and AI agents.
Website checker for AI coding agents. Measures your site in a real browser, with evidence.
Multi-brand AI code review for Claude: up to 12 reviewers and a judge, no install.
Related MCP Servers
- AlicenseBqualityDmaintenanceProvides professional UI/UX design expertise and frontend development tools for analyzing interfaces, generating design systems, and creating modern components with accessibility and best practices built-in. Supports React, Vue, Angular and other frameworks with seamless Claude Code CLI integration.423MIT
- AlicenseAqualityDmaintenanceCore Web Vitals analysis powered by Lighthouse. Four tools: analyze a URL, compare two URLs, check against thresholds, or crawl an entire site. Works with Claude Code, Cursor, Windsurf, and any MCP-compatible AI tool.414 npmMIT
- AlicenseAqualityDmaintenanceEnables Claude Code to capture and analyze web page screenshots, responsive layouts, and page metadata using Puppeteer. It allows developers to perform visual UI inspections and compare designs across various viewports directly within the terminal.3MIT
- AlicenseAqualityCmaintenanceAI design fidelity — compare Figma designs or screenshots against the rendered implementation and get structured discrepancies. Uses your Claude Code or Codex subscription, no API keys.31MIT