lint
An agent-first ESLint and Oxlint plugin that turns Tailwind design-system violations into fix instructions a coding agent can act on.
Worth a pilot if you already run coding agents against a Tailwind v4 codebase. The linting is table stakes; the product is the error text — machine-readable and pre-loaded with your design system's guidance, delivered through shadcn/no-restyle contracts and shadcn/no-arbitrary-values. The 150+ task-run numbers are specific enough to be falsifiable: near-zero violations after one correction round, and Claude runs 10–48% cheaper than rules alone. It's narrowly scoped on purpose, works with ESLint or Oxlint, and doesn't require shadcn/ui. If you want a general-purpose JS linter, use ESLint's own rules; if you need a hosted dashboard or CI product, look elsewhere. Pilot it on one Tailwind v4
Verified 7d ago · liveness 60/100 · cite: rightaichoice.com/tools/lint
- Teams running coding agents on a Tailwind v4 codebase who want machine-readable design system constraints
- Design system maintainers who need enforceable per-component rules rather than prose guidelines
- Frontend engineers on Tailwind v4 who want component, variant, and theme-aware lint output
- shadcn/ui users and non-users who want lint errors an agent can act on without human translation
- Projects on Tailwind v3 or earlier
- Teams looking for a general-purpose JavaScript or TypeScript linter
- Anyone needing a hosted service, dashboard, or CI product — this is a repo-level linter
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip @shadcn/lint if your project is on Tailwind v3 or earlier, or if you don't run coding agents — the agent-readable error text is the whole point, and there's no hosted dashboard or CI product behind it.
It's MIT-licensed and free at any scale — there's no seat, usage, or compute charge. The real cost is engineering time: writing per-component contracts and category allows takes a few hours of a frontend engineer's attention, and you'll need to revisit configs as your design system evolves. Compared with free general-purpose linters like ESLint core rules, @shadcn/lint costs nothing but expects you to supply design system rules.
In short
lint — An agent-first ESLint and Oxlint plugin that turns Tailwind design-system violations into fix instructions a coding agent can act on. Best for Teams running coding agents on a Tailwind v4 codebase who want machine-readable design system constraints, Design system maintainers who need enforceable per-component rules rather than prose guidelines, Frontend engineers on Tailwind v4 who want component, variant, and theme-aware lint output. Free to use.
Viability Score
How well maintained and how widely used is lint? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: September 2026
How we score →Key Features
- Agent-first rule model where you declare what your design system allows
- Lint errors explain the violation and suggest a fix drawn from your components, variants, and theme
- shadcn/no-restyle rule with per-component contracts using pattern, allow, and deny lists
- shadcn/no-arbitrary-values rule keeps classes on your theme's spacing scale
- Per-part component rules — CardTitle can change typography, CardContent spacing
- Custom messages and contracts attach your design system's instructions to errors
- Category allows for layout, spacing, and typography
- Works with Tailwind v4 projects with no rewrite of the existing design system
- shadcn/ui not required to adopt the linter
- Available as an ESLint integration
- Available as an Oxlint integration
- Agent-oriented setup prompt that reads SETUP.md and installs @shadcn/lint
- Rule testing across 150+ coding-agent task runs with near-zero violations after one correction round
- Claude control runs fixing violations with lint feedback cost 10–48% less than with rules alone
- MIT licensed, distributed via a pnpm workspace monorepo with changeset-based releases
About lint
@shadcn/lint is an open-source linter for Tailwind design systems, built on the premise that coding agents write UI now — so the errors they receive should be instructions, not verdicts. You declare what your design system allows — which components exist, which variants they have, which theme tokens they can touch — and when an agent breaks a rule, the message names the violation and points at a fix pulled from your own components, variants, and theme. The rule set is contract-based rather than type-based: shadcn/no-restyle takes per-component contracts with pattern, allow, and deny lists, so a CardTitle can change typography while a CardContent changes spacing. Pair it with shadcn/no-arbitrary-values and spacing stays on your theme's scale instead of drifting into arbitrary pixel values. Custom messages and contracts attach your design system's own instructions to the error text. It works with Tailwind v4 projects, requires no rewrite and does not require shadcn/ui. It ships as an integration for both ESLint and Oxlint. The maintainers tested the rules across more than 150 coding-agent task runs; most tasks reached zero violations in one correction round, and Claude control runs that fixed violations with lint feedback cost 10–48% less than with rules alone. The repo is early but active (22 commits, 2.3k stars, 44 forks). It is not a general-purpose JavaScript linter and not a hosted lint service with a dashboard. Compared with enforcing the same policies through TypeScript prop types, the difference is that types tell an agent padding isn't allowed while @shadcn/lint tells it what to use instead. It is MIT licensed, so treat it as a pilot rather than infrastructure.
Behind the Verdict
The interesting thing here isn't the linting — ESLint already lints. It's the audience the error message is written for. Most lint rules are written for a human who will read the warning and then decide what to do. @shadcn/lint writes for an agent that will read the warning and then act. That distinction drives everything else about the tool: the rule shapes (contracts with pattern, allow, and deny lists), the fix suggestions drawn from your own components, variants, and theme, and the custom message field that lets you paste your design system's actual guidance into the error. Strengths. The rule model maps cleanly onto how design systems actually constrain UI. Per-part contracts mean a CardTitle can change typography while its font-family and weight stay locked, and a CardContent can adjust spacing without touching type — that granularity is hard to express in TypeScript without elaborate types, and @shadcn/lint expresses it in a config object. The shadcn/no-restyle rule handles restyling violations, and shadcn/no-arbitrary-values keeps spacing on your theme's scale instead of letting p-[13px] sneak in. It works with Tailwind v4 projects, doesn't require a rewrite, and doesn't require shadcn/ui. Integration with both ESLint and Oxlint means violations can fail the same pass as your other lint errors. The measured behavior — 150+ agent task runs, near-zero violations after one correction round, Claude runs 10–48% cheaper with lint feedback than rules alone — is unusually concrete for a design-tooling announcement. Weaknesses. The repository is young: 22 commits, 44 forks, and a small folder set, so rule coverage and edge-case handling should be expected to move. Scope is Tailwind v4 only — v3 and earlier aren't supported. There's no hosted service, no dashboard, no CI product; it's a repo-level linter you install yourself. Teams without defined design system rules will need to write them first, because the linter enforces a contract you have to supply. And if you don't run coding agents, the headline benefit largely evaporates — you're left with a normal lint rule that a human reads. Where it fits. Frontend teams already running Claude Code, Copilot, or similar agents against a Tailwind v4 codebase, especially those who have written design system guidelines in prose and want machine-enforceable versions. Where it doesn't: greenfield projects without a design system, Tailwind v3 codebases, and anyone shopping for a hosted lint service with a dashboard or a general-purpose JS/TS linter.
Researching lint? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas lint actually fits — and what changes day-one when you adopt it.
You write per-component contracts in your ESLint config: allow layout on Button with mt-* and mb-* but deny padding changes, let CardTitle change typography while denying font-*, and let CardContent change spacing.
Outcome: Agents editing components hit errors that name the violation and point to a size, variant, or theme-friendly alternative instead of pasting arbitrary pixel values.
You paste the SETUP.md prompt into your agent, install @shadcn/lint, then run lint after each agent edit so violations surface in the same pass as your other lint errors.
Outcome: Most agent tasks reach zero violations after a single correction round, and Claude runs come out 10–48% cheaper than without lint feedback.
You pilot the linter on one Tailwind v4 repo, measuring how often agents self-correct on lint feedback versus merging violations.
Outcome: You get concrete data on whether design system enforcement actually reduces agent drift before rolling it out across repos.
Use Cases
- Encode your design system's allowed components, variants, and theme tokens as lint rules an agent must satisfy.
- Run the linter after an agent edits Tailwind classes so the agent reads the error and self-corrects.
- Give a coding agent the SETUP.md prompt to install and configure @shadcn/lint in a Tailwind v4 project.
- Wire @shadcn/lint into ESLint or Oxlint so design system violations fail the same pass as other lint errors.
- Adopt the linter on an existing Tailwind v4 design system without rewriting components.
- Point agents at concrete fix suggestions generated from your own components rather than generic Tailwind advice.
Limitations
- Scope is limited to Tailwind v4 projects — v3 and earlier are not supported.
- There is no hosted service, dashboard, or paid tier; this is a repo-level linter you install from GitHub.
- The project is very early relative to its ambition: 22 commits and 44 forks, so rule coverage and edge-case handling should be expected to evolve.
- Teams that haven't defined design system rules will have to write them before the linter has anything to enforce.
- If your team doesn't run coding agents on the codebase, the agent-readable error text — the main differentiator — won't deliver much value.
as of 2026-09-21
Verification history
We have re-verified lint 5 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-checked, vendor evidence unchanged
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published lint tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Open Source (MIT)
$0
Ideal for
Any team on Tailwind v4 running coding agents that needs machine-readable design system constraints — there is only one tier and it costs nothing.
What this tier adds
Starting tier, and the only tier — MIT-licensed, free, distributed via GitHub with ESLint and Oxlint integrations, and no shadcn/ui requirement.
Where the pricing makes sense
The company stage and team size where lint's pricing actually pencils out — and where peers do it cheaper.
It's MIT-licensed and free at any scale — there's no seat, usage, or compute charge. The real cost is engineering time: writing per-component contracts and category allows takes a few hours of a frontend engineer's attention, and you'll need to revisit configs as your design system evolves. Compared with free general-purpose linters like ESLint core rules, @shadcn/lint costs nothing but expects you to supply design system rules.
Setup time & first value
How long it actually takes to get something useful out of lint — broken out by persona, not the marketing-page minute.
For a Tailwind v4 repo, budget 5–10 minutes for install (paste the SETUP.md prompt into your coding agent, or follow the Get started docs) and another 30–60 minutes to write your first set of contracts and category allows. Teams without existing design system rules should expect longer, since the linter enforces a contract you have to author first. There's no account signup, no environment
Integrations
Resources & Guides
- Resourcegithub.com
Lint · lint
Helpful link from github.com
- Resourcegithub.com
SETUP · lint
Helpful link from github.com
- Resourcegithub.com
README · lint
Helpful link from github.com
- Resourcegithub.com
CONTRIBUTING · lint
Helpful link from github.com
- Documentationgithub.com
Docs · lint
Full product docs from github.com
Tutorials & Learning
YouTube returned 6 videos for “lint”, and we withheld 6: 6 could not be judged, because “lint” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about lint.
Official links
Tools that pair well with lint
Common stack mates teams adopt alongside lint, with the specific reason each pairing earns its keep.
Open Design
Open Design turns your coding agent into a local-first AI design engine for prototypes, slides, and HTML video
Subframe
Subframe is the AI design tool that turns a visual canvas into real React + Tailwind code your team can ship.
Design.MD
DESIGN.md files that give AI coding agents real brand design references — colors, type, spacing and the reasoning behind them.
Featured Head-to-Head Comparisons
Lint vs Make Real Tldraw
These products are not competitors and nobody is choosing between them. If you ship a Tailwind v4 codebase with a design system — shadcn/ui or not — and coding agents write your UI, @shadcn/lint is the pick: it encodes per-component contracts and returns fix instructions in the error message. If you want to sketch a layout on a canvas and see a clickable prototype in minutes, Make Real Tldraw is the pick, and you'll need to supply your own OpenAI, Anthropic or Google key. Buy the one that matches your problem; owning both is plausible, choosing one over the other isn't the question.
Lint vs Poolside Ai
These are not competitors, so there is no pick-one decision. Poolside AI is for organizations that cannot send code to a third-party cloud and need to own the weights, run agents behind their own perimeter, and show auditors RBAC and end-to-end traces — you buy it through procurement, and the lack of a published per-seat price is itself the gating factor. lint solves a completely different problem one layer down: it is a free plugin that stops coding agents from drifting off your Tailwind v4 design system by returning violations plus fixes pulled from your own components and theme. A regulated enterprise could plausibly use both, but nobody evaluating a governed agent platform is choosing it over an ESLint plugin.
Lint vs Audioeye
These two are not competitors, and a buyer should not be choosing between them. @shadcn/lint is a free, open-source linter that encodes your Tailwind v4 design system as machine-readable contracts so coding agents fix UI violations without human translation — you install it in a repo. AudioEye is a paid enterprise compliance platform that scans, remediates, monitors, and documents accessible websites, with overlays and human expert audits behind it. If you write the code, pick the linter; if you have to prove and defend compliance, pick the platform. Buying one tells you nothing about whether you need the other.
Lint vs Roo Code
These aren't competitors — they belong to different buying decisions. Roo Code is a pre-launch VS Code coding assistant with no pricing, demo, or downloadable extension yet, so anyone needing a working tool today should keep looking and only sign up if they want to evaluate unfinished software. @shadcn/lint solves a narrower, real problem right now: it makes Tailwind v4 design-system violations readable and fixable by coding agents, for free, through ESLint or Oxlint. If you run agents on a Tailwind v4 codebase, lint is the actionable pick; Roo Code is a wait-and-see.
Lint vs Bito
These rarely compete for the same dollar — they compete for the same slice of your agent loop. Bito is the spend-and-context layer: a base-URL swap that grounds requests in your codebase and routes them by complexity, priced behind a sales conversation with a free tier to start. lint is free and does one narrow thing: it makes Tailwind v4 design-system violations machine-readable so an agent can fix them without a human translator. If your problem is a climbing coding-agent bill across many repos, budget for Bito's scoping work. If your problem is agents quietly restyling your design system into arbitrary pixels, lint costs nothing and installs in minutes. A disciplined Tailwind v4 shop can plausibly run both.
Lint vs Replit Agent
These are not competitors — a buyer is never picking one over the other. lint is a free, open-source ESLint/Oxlint plugin that turns Tailwind v4 design-system violations into machine-readable fix instructions so coding agents stop guessing at your component contracts. Replit Agent is a freemium browser-based builder that goes prompt-to-deployed-app and now reads Slack (including private conversations) and ships mobile voice input. If your problem is agent-generated UI drift on an existing Tailwind v4 codebase, install lint. If your problem is getting an app built and hosted by Friday, use Replit Agent. You could plausibly use both, but you would never choose between them.
Alternatives to lint
View all
Open Design
Open Design turns your coding agent into a local-first AI design engine for prototypes, slides, and HTML video
Frequently Asked Questions
Best-of guides
Used lint? Help shape our editorial sentiment research.