Three Skills That Teach Your Agent Taste: Taste Skill, Impeccable, Hallmark

Ask any coding agent for a landing page and you can predict the output before it renders: a purple-to-pink gradient hero, Inter doing both display and body, a centred headline, three symmetrical feature cards each with an icon in a rounded square. It works, it ships, and it looks exactly like the last forty pages the same model produced. The community named it AI slop, and it isn’t a bug. It’s a model faithfully reproducing the median of its training data.

The fix turns out not to be a better model. It’s constraints. Over the past year a small category has formed around that idea: design skills, plain markdown rule files an agent reads before it writes a line of code, telling it what good looks like and, more importantly, what it must not reach for. Three of them are worth knowing, and they make genuinely different bets. Taste Skill offers a menu of modular skills with dials, Impeccable is a whole design language with commands and CI enforcement, and Hallmark is one opinionated ruleset that refuses to repeat itself.

This post takes each one in turn (what it does, how it installs, what it’s good and bad at), then compares them head to head. It also flags something I ran into while researching: the secondary coverage of these tools is unusually unreliable, so several “facts” circulating about them are wrong.

What it is

A design skill is not a component library, a UI framework, or a design system. It’s an instruction file, usually SKILL.md plus reference documents, that a coding agent loads into context and treats as a brief. It contains positive rules (“pair a display face with a body face”), negative constraints (“never a gradient background on a hero”), and often a self-check the agent must pass before handing work back.

The category targets developers who can build any interface but can’t specify a good one, and who are tired of hand-editing away the same five clichés. All three tools here are free and open source (Taste Skill and Hallmark under MIT, Impeccable under Apache 2.0) and install in a command or two into Claude Code, Cursor, Codex and friends.

It’s worth knowing the baseline they build on. Anthropic ships a frontend-design skill for Claude Code, and Impeccable’s own README describes itself as starting from there. If you’ve never used any of this, that skill is the floor; the three below are attempts at a ceiling.

Why it matters

Negative constraints work better than positive ones. Telling a model what not to do pushes it off its default trajectory. “No Inter” forces an actual font decision; “no pure black” forces tinted neutrals. This is the mechanism, and it’s why the anti-pattern lists are the load-bearing part of all three.
It closes a vocabulary gap, not a capability gap. The model can already produce OKLCH palettes with tinted neutrals and a fluid type scale. It just never gets asked, because most of us can’t name those things. The skill supplies the vocabulary.
It’s portable and inspectable. These are markdown files, so you can read every rule, fork it, and delete the ones you disagree with, which a hosted design tool won’t let you do.
It survives the model. A rule file works across Claude, GPT, and Gemini builds, and keeps working when you switch.

How it works

All three follow the same four-stage skeleton:

The brief goes in: what you asked for, in plain language.
The skill forces a deliberate direction, instead of letting the model fall back on whatever design it saw most often in training, which is exactly where the purple gradient comes from.
The agent generates the interface against that direction.
Something checks the result before it reaches you.

Stages 1 and 3 are the same everywhere. Where the three diverge is stages 2 and 4, and that difference is the whole choice between them, which is why the diagram below shows only those two.

The same two decisions, made three ways: how each skill sets the direction (teal) and how it checks the result (amber). Each project's own vocabulary is kept (dials, modes, macrostructures, gates) with what it means alongside. Sources: each project's own documentation.

That second column deserves unpacking, because “verification” means two very different things here. For Taste Skill and Hallmark it is a self-check: the skill file ends with a checklist, and the agent is instructed to confirm every item honestly before handing the page back. It’s the model marking its own homework. That is useful, because a written checklist demonstrably catches things a model would otherwise skip, but it is still the same model that just made the mistakes. Impeccable is the exception: its detector is ordinary deterministic code, so its hooks can reject an edit mid-flight and npx impeccable detect can fail a build. One is a prompt; the other is a program.

All three also emit a portable spec, so your visual system can move to another tool instead of living in one agent’s head. Two converge on the DESIGN.md format published by Google Stitch, Google’s AI UI-design tool, whose spec defines how to write a design system in markdown so that any Stitch-aware tool can read it. Taste Skill exports it via its stitch-skill, Impeccable via /impeccable document. Hallmark writes its own design.md and never mentions Stitch. That partial convergence is the clearest sign the category is starting to standardise.

The three skills, one by one

Taste Skill by Leon Lin (@lexnlin) and blueemi is the most modular of the three: not one skill but a dozen, each doing one job. The README lists nine implementation skills, a general-purpose default (design-taste-frontend), a stricter GPT/Codex variant (gpt-taste), plus specialists for redesigns, image-to-code pipelines, and three fixed visual directions (high-end-visual-design, minimalist-ui, and industrial-brutalist-ui, which the README flags as beta), and three image-generation skills that output reference boards rather than code.

Its distinguishing feature is numeric control. The default skill exposes three 1-to-10 dials at the top of the file: DESIGN_VARIANCE (how far layout deviates from centred and clean), MOTION_INTENSITY, and VISUAL_DENSITY. In v2 the agent infers these from the brief; you override them by editing the top of the file.

The current default is a v2 rewrite the project labels experimental: the agent now infers the brief’s industry and mood before generating (§0), maps the brief to an appropriate design system, one of a dozen from Material and Carbon to Radix and shadcn, versus plain CSS (§2), and must pass a hard pre-flight check before shipping (§14). The project warns that both the rule wording and the section numbering may change before v2.0.0 stable, so treat those § references as current-at-writing.

Pros: the finest-grained control of the three; pick exactly the visual direction you want; image-generation skills are unique here; broad agent support (eight listed on the homepage, twelve in the docs).

Cons: the menu invites over-installing, and stacking competing skills is the classic way to confuse an agent; the default is self-described experimental; the dials are documented in one line each, so getting them right is trial and error.

Impeccable: a design language with enforcement

Impeccable by Paul Bakaus (@pbakaus) is the most ambitious: one skill plus 23 commands that form a shared vocabulary with your agent, /typeset for type, /distill for complexity, /polish for a final pass, /audit for production quality. Its slop detector runs 58 checks for the defaults agents reach for.

Three things set it apart. First, it names the purpose of a surface before designing, Persuade, Operate, Read, or Experience, on the logic that a landing page and a dashboard should not be designed the same way. Second, it reads real project context: a PRODUCT.md you write once (users, mode, brand voice, anti-references) that every command consults. Third, and most distinctively, it enforces. Hooks inspect each UI edit and feed findings back to the agent mid-flight, a Chrome extension runs the detector on any page, and npx impeccable detect src/ runs in CI with JSON output and exit codes so a PR can fail on slop.

It also ships a Live Mode that generates visual variants against your running app and writes the accepted one to source, and a “worlds” mechanic that deals human-reviewed complete graphic systems as challengers to the model’s own ideas.

Installation is the heaviest of the three because it compiles a build tailored to your harness: npx impeccable install (Node 22.12+), then /impeccable init. Claude Code gets hooks and a subagent, Cursor a pre-edit hook, and the Gemini and Codex builds carry extra rules banning those specific models’ known tells. It’s built into the GitHub Copilot app under Settings → Experimental.

Pros: the only one that can enforce rather than suggest (hooks, CI, exit codes); per-model tuning is genuinely clever; broad harness support plus the Copilot integration; explicitly inherits your existing tokens and components rather than overwriting them.

Cons: the heaviest install and the largest surface to learn; a freemium seam, since the worlds deck grows weekly in a paid Pro tier; and its own documentation can’t agree on how big the detector is, advertising “58 checks” on the homepage, “59 deterministic rules” for the CLI on that same page, and 44 deterministic rules in the README. Since CI enforcement is the main reason to choose Impeccable, that’s the one number you’d want pinned down.

Hallmark: one opinion, four verbs

Hallmark, made by Together AI, is the tightest of the three: a single ruleset with one default behaviour and three explicit verbs. Ask for a page and it builds one; hallmark audit scores existing code against the anti-patterns and returns a ranked punch list with no edits; hallmark redesign keeps your copy, IA and brand but throws out the structure and rebuilds with a different fingerprint; hallmark study takes a screenshot or URL and extracts its DNA, meaning macrostructure, type pairing and colour anchor, optionally emitting a portable design.md.

Its mechanism is the most explicit about structural variety. Hallmark picks a macrostructure first, dresses it in one of twenty themes, runs fifty-seven slop-test gates plus a pre-emit self-critique, and refuses to repeat any of its last three macrostructures. When a brief fits no catalogue theme, a Custom branch designs from scratch under the same gates. Output is self-contained HTML and CSS, stamped with its macrostructure in a CSS comment.

It also names its enemies plainly, which is the best documentation in the category: the purple-gradient hero, Inter as display, centred everything, the icon-tile feature card, and “the AI nav” (wordmark left, four links centred, CTA right, sticky, hairline border). Eight foundations hold across every theme, including OKLCH palettes with the accent under five percent, spacing in multiples of four, and a reduced-motion alternative for every animation.

The study verb has a refusal layer worth noting: it reads structure, not pixels, and declines to identify fonts or clone paid templates.

Pros: the least to learn and the fastest to get value from; the strongest explicit anti-repetition mechanism; study is a genuinely novel way to transfer a reference’s structure without copying it; honest, legible documentation.

Cons: the narrowest agent support (Claude Code, Cursor, Codex only); no enforcement layer, meaning no hooks and no CI gate; twenty themes is a catalogue, so heavy users may start recognising the house style; and at v1.1 it’s the least-iterated of the three.

How it compares

Dimension	Taste Skill	Impeccable	Hallmark
Shape	~12 modular skills	1 skill + 23 commands	1 skill + 4 verbs
Control model	Numeric dials	Command vocabulary	Macrostructure + theme
Verification	§14 pre-flight check	detector (44 to 59, sources differ) + hooks + CI	57 gates + self-critique
Enforcement	None	Hooks, CI exit codes, Chrome ext.	None
Agents	8 on the homepage, 12 in the docs	11 in the README; built into Copilot	3 (Claude Code, Cursor, Codex)
Install	`npx skills add Leonxlnx/taste-skill`	`npx impeccable install` (Node 22.12+)	`npx skills add nutlope/hallmark`
Portable spec	`stitch-skill` → DESIGN.md	`/impeccable document` → DESIGN.md	`lock the DNA` → design.md
Money	OSS + GitHub sponsors	OSS + paid Pro tier	OSS, backed by Together AI
Maturity	v2 (experimental)	v4	v1.1

Be fair to each: they’re solving overlapping problems with legitimately different philosophies. Taste Skill is right if you already know the visual direction you want and need the agent to hit it precisely. Impeccable is right if design quality has to be a team standard rather than a personal preference, since it’s the only one that can fail a pull request. Hallmark is right if you want one good decision made for you and you value structural variety over configurability.

Performance and benchmarks

Here is the uncomfortable part: there is almost no independent evidence that any of this works. Design quality is subjective, and two of the three publish no evaluation at all.

The single exception is a third-party benchmark of Impeccable by Tessl, reported by paddo.dev in March 2026 across three scenarios (a revenue dashboard, a landing page, a task manager): an aggregate score of 0.82/1.00, an improvement of +0.35 over baseline, a 1.59x multiplier, with OKLCH colour usage going from 0 to 12/12 once the skill was active.

Read that with the caveats its own reporter names: “Benchmarks test their own criteria.” Tessl measured the things Impeccable optimises for, which makes the result useful signal but somewhat circular. It also describes an earlier version, since that write-up counts 17 commands where the current site advertises 23, so it does not measure what ships today.

The other two publish no benchmark at all. What they publish instead is self-produced before/after evidence: Hallmark shows the same prompt run with and without the skill on Sonnet 4.6, Taste Skill shows a gallery of sites built with it, and Impeccable’s homepage carries two marquee rows of enthusiastic testimonials. All three are demonstrations, not measurements. Judge them the same way.

And note what the rule counts are not. Fifty-seven gates, fifty-eight checks, a pre-flight checklist: these are deterministic lint-style rules. They can prove a page contains no purple gradient and no untinted black. They cannot prove it’s beautiful, or that a user will convert on it. Treat the numbers as compliance metrics, not quality metrics.

Tradeoffs

Vocabulary is not taste. The phrase is paddo’s, in a write-up otherwise enthusiastic about Impeccable, which is what makes it worth quoting. It’s the honest ceiling on the whole category: knowing the term “tinted neutrals” doesn’t mean knowing when to use them. These tools raise the floor of AI-generated design considerably. They do not supply judgment.
Anti-slop risks becoming its own slop. My inference, not a claim any of them make: the three ban-lists overlap less than you’d think, since only the purple gradient and Inter-as-display are forbidden by all three, but they steer toward the same remedies: asymmetric layouts, paired display and body faces, OKLCH palettes with a restrained accent, editorial serif display type. If they succeed and get widely adopted, pages built with them will start to look like each other. The tells being banned today were themselves once the mark of good taste.
Context cost is real and recurring. Reference files load into context on every relevant task. You pay for design vocabulary on jobs that may not need it, and the larger the ruleset the more you pay.
Opinionated defaults are someone else’s taste. “No bounce easing” is a preference codified as a rule. Adopting a skill means adopting its author’s aesthetics wholesale unless you fork and edit it.
Single-generation scope. Multi-page and multi-session consistency is still mostly your problem. The portable DESIGN.md export is the partial answer all three now offer, but it’s a handoff format, not a guarantee.
The secondary coverage is unreliable, so verify before you trust it. While researching this I checked one widely-circulated comparison piece against the projects’ own documentation. The install command was wrong for both Taste Skill and Impeccable, the anti-pattern count contradicted the official site, and two of the three dials it names don’t exist while both real ones are missing. That isn’t a swipe at one author. This space moves fast enough that command syntax, version numbers and feature lists go stale in weeks, and the same is true of anything I’ve written above. Read the README.

Takeaway

If you want one recommendation and no configuration, start with Hallmark: four verbs, honest documentation, and the strongest guarantee that two pages won’t look like the same template. If design standards need to hold across a team and survive a code review, take Impeccable, the only one that enforces rather than advises, with per-harness builds that are real engineering. If you already know exactly the look you want and resent presets, Taste Skill exposes numeric dials nobody else does, and lets you pick a fixed visual direction outright. Install one, not three. And keep the ceiling in mind: these tools reliably stop your agent producing the median, which is a large and immediate win, but the judgment about whether the result is actually good is still yours, and no rule file has taken that over yet.

Sources

Taste Skill site, docs and README: skill list and install names, the beta flag on industrial-brutalist-ui, the three 1-to-10 dials, v2 §0/§2/§8/§11/§12/§14 structure, the experimental-stability note covering section numbering, supported-agent counts, MIT licence, authorship.
Impeccable site and README: 23 commands, npx impeccable install and Node 22.12+, per-harness builds, PRODUCT.md and DESIGN.md, Live Mode, the worlds deck, Chrome extension and npx impeccable detect, the four surface modes, Copilot integration, Pro tier, Apache-2.0 licence, and the 58 / 59 / 44 detector-count discrepancy across homepage, CLI card and README.
Hallmark site and README: four verbs, twenty themes, fifty-seven slop-test gates plus pre-emit self-critique, the last-three-macrostructures refusal, Custom branch, the five named anti-patterns, the eight foundations, install paths, Together AI, MIT.
paddo.dev, “Impeccable: The Design Vocabulary AI Was Missing”: March 2026; the third-party Tessl benchmark figures (0.82/1.00 aggregate, +0.35 / 1.59x, OKLCH 0 to 12/12), the “vocabulary isn’t taste” framing, and the circular-benchmark and context-cost caveats.
Google Stitch DESIGN.md specification: the portable format all three converge on.