Your team corrects once. NeuralDiff remembers forever.
A neural network that learns your team's design standards from every correction. AI generates UI faster than ever — NeuralDiff makes sure it's right.
AI builds UI fast. Nobody checks if it's right.
AI coding tools generate interfaces in seconds. But they don't know your design system. They don't remember that your team prefers 8px radius over 12px. They repeat the same mistakes your designer already corrected last sprint.
of AI-generated UI changes require visual corrections
the same visual feedback given repeatedly across sprints
tools that learn from your corrections to prevent repeats
The correction flywheel
Every human correction makes NeuralDiff smarter. The more your team uses it, the fewer issues slip through.
Human Spots a Visual Issue
A developer in local dev or a stakeholder in the review UI notices something wrong — wrong spacing, off-brand color, broken layout.
Before & After Screenshots Captured
The wrong screenshot and the corrected screenshot form a labeled training pair. These aren't text rules — they're real visual examples of what your team considers a defect.
Embedded Into Design Space
Each pair is embedded into a high-dimensional vector space. The model learns the visual pattern of the defect — not "8px radius" as a string, but what wrong spacing looks like across contexts.
Similar Patterns Caught Automatically
Future screenshots are compared against the embedding space. Visually similar defects are caught by proximity — even in components the model has never seen before.
See what NeuralDiff sees
Drag the slider to compare. Three subtle defects — wrong spacing, wrong radius, wrong color. Each one becomes a training pair in the embedding space.
A visual system that gets smarter over time
Not another pixel-diffing tool. A neural network trained on your team's design decisions.
Learns From Every Correction
When you fix a visual issue, NeuralDiff remembers. Every correction becomes a rule — spacing, color, typography. Your team never repeats the same feedback twice.
Per-Team Design Intelligence
No universal "design rules" — NeuralDiff builds a model specific to your product. It knows your spacing system, your color palette, your component patterns. Trained by your team's actual decisions.
AI Agent Native
Built as an MCP server for Claude Code, Cursor, and other AI agents. Before generating UI, your AI checks NeuralDiff's learned rules. After generating, NeuralDiff verifies the output.
Sub-Second Local Feedback
The daemon watches your UI in real-time as you code. Instant feedback on changes that violate your team's learned standards — no CI wait, no context switch.
Stakeholder Review UI
Non-technical team members catch visual issues in a simple web interface. Click what's wrong, describe the fix. That correction trains the system — no Jira ticket required.
Semantic, Not Pixel
NeuralDiff understands what changed — font size, button color, layout shift — and how severe it is. Not pixel noise. Meaningful, categorized, actionable diffs.
Growing Embedding Space
Every correction adds a before/after pair to the vector space. The model doesn't memorize rules — it builds geometric intuition about what your team considers a defect. More corrections = tighter clusters = fewer false positives.
CI/CD Integration
Block merges on learned violations. NeuralDiff checks PRs against your team's accumulated design knowledge — not just pixel diffs, but pattern violations your team has flagged before.
Predicts Before You See It
As NeuralDiff's neural model trains on your corrections, it begins predicting issues before a human reviews. The endgame: violations caught at code generation time, not after deploy.
Two feedback loops, one system
Developers get instant local feedback. Stakeholders review in the browser. Both teach NeuralDiff what "right" means for your product.
Fast local feedback while you code
- Daemon watches your UI in real-time
- Sub-second violation detection against learned rules
- MCP integration — AI agents check before generating
- Corrections from your terminal feed the knowledge base
$ neuraldiff watch ./src
Watching 47 routes...
⚡ /settings — changed detected (6ms)
⚠ Rule #47 violated: button radius 12px → 8px
✓ /dashboard — no violations
✓ /profile — no violationsNon-technical review that trains the AI
- Visual review UI — click what's wrong, describe the fix
- No Jira tickets, no Slack threads — corrections go straight to the model
- Deploy previews with automatic violation detection
- Every approval or rejection sharpens the neural model
Your AI agent's design-aware watchdog
// Diffy checks your screenshot against 142 learned patterns:
{
"diffy": {
"verdict": "Two patterns match known defects.",
"corrections_in_space": 142,
"matches": 2
},
"findings": [
{ "pattern": "spacing-regression", "distance": 0.08,
"similar_corrections": 12, "confidence": 0.97 },
{ "pattern": "color-drift", "distance": 0.11,
"similar_corrections": 8, "confidence": 0.94 }
]
}Diffy is the opinionated AI agent inside NeuralDiff. It doesn't match text rules — it measures distance in an embedding space built from your team's correction history. Each before/after pair teaches it what defects look like for your product. Built as an MCP server, Diffy works inside Claude Code, Cursor, and other AI tools.
Up and running in minutes
Install the SDK, capture your UI, teach NeuralDiff what "right" means. It only gets smarter from there.
Give Your AI Eyes
Add the MCP server to Claude Code, Cursor, or any AI coding tool. Your agent gets visual regression tools — capture, compare, and check against your team's rules.
// .mcp.json (or claude_desktop_config.json)
{
"mcpServers": {
"neuraldiff": {
"command": "npx",
"args": ["@neuraldiff/mcp"]
}
}
}AI Captures Your Live UI
The daemon runs locally and captures your app in a real browser. First capture becomes the baseline. Every capture after is compared automatically — no static PNGs, no manual screenshots.
# Your AI agent calls this automatically:
neuraldiff_capture({
url: "http://localhost:3000/dashboard",
viewport: { width: 1280, height: 720 }
})
# → Baseline established. Next capture
# compares against it automatically.Correct Once, Enforce Forever
When Diffy flags a change, approve or reject it. Each correction becomes a before/after training pair — embedded into a vector space that encodes what your team considers a defect. Not text rules. Visual understanding.
# Diffy's verdict after a UI change:
{
"diffy": {
"verdict": "Spacing pattern diverges from team norm",
"confidence": 0.94,
"similar_to": "12 previous corrections"
},
"embedding_distance": 0.12,
"nearest_correction": {
"pair_id": "corr_2847",
"pattern": "spacing-regression",
"distance": 0.08
}
}Review in the Dashboard
Non-technical teammates review visual changes in the web UI. Click what's wrong, describe the fix. No Jira tickets — corrections go straight into the knowledge base.
# What your stakeholder sees:
┌─────────────────────────────────┐
│ PR #142 — Visual Review │
│ │
│ ⚠ 2 issues found │
│ │
│ ✕ Header spacing 16px → 24px │
│ [Mark as Issue] [Approve] │
│ │
│ ✕ CTA color shifted to #6b7280 │
│ [Mark as Issue] [Approve] │
│ │
│ Every click trains the model → │
└─────────────────────────────────┘Start free. Scale as your model grows.
Local analysis is always free. Cloud features unlock team collaboration and neural model training.
Open Source
Local analysis, unlimited
- Local daemon + SDK
- MCP server for AI agents
- Local knowledge base
Team
Shared knowledge base
- Team-shared learned rules
- Stakeholder review UI
- CI/CD visual checks
Business
Neural model training
- Custom neural model per team
- Predictive violation detection
- Cross-browser + responsive
Enterprise
Self-hosted, dedicated model
- Self-hosted deployment
- SSO / SAML
- SLA & dedicated support
Stop repeating visual feedback.
Every correction your team makes today becomes a rule NeuralDiff enforces tomorrow. Start building your design intelligence now.