DEV Community

Cover image for Stop AI Design Skills from Rewriting Your Billing Forms
linweidao
linweidao

Posted on

Stop AI Design Skills from Rewriting Your Billing Forms

Stop AI Design Skills from Rewriting Your Billing Forms

You ask the AI to "add a loading spinner." It ships a diff that replaces your payment form's label structure, drops ARIA attributes, and introduces a decorative gradient that breaks WCAG contrast requirements. The build passes. The screenshot looks "modern." Production deploys.

Then support tickets arrive: screen readers announce the wrong fields, keyboard navigation skips the submit button, and your compliance audit flags accessibility regressions.

Nutlope/hallmark is a design skill for Claude Code, Cursor, and Codex that tries to push AI-generated interfaces past the "centered heading, rounded card, soft shadow" plateau. I evaluate it as bounded design guidance, not as ambient policy that touches every file.

That distinction determines the integration: load its instructions for deliberate design work, preserve application constraints separately, and validate results in an actual browser.

The failure mode: design guidance becomes ambient authority

A global instruction like "make every screen distinctive" sounds useful until an agent applies it to a billing form that already follows an established interaction pattern.

The resulting diff can be visually interesting and operationally wrong. Labels disappear. Shared controls get replaced with page-specific variants. A decorative treatment reduces contrast. None of those failures necessarily break compilation.

The problem is instruction scope. Hallmark should influence visual composition. Your application's existing components, accessibility requirements, and functional behavior remain constraints. A design skill should not silently acquire authority over those boundaries.

For Cursor, I prefer a manually invoked project rule over automatically attaching design guidance to every frontend file. That makes a design pass an explicit operation rather than background behavior during unrelated maintenance.

Architecture: source, adapter, application

There are three separate layers.

The source layer is a pinned checkout of Hallmark. Record the commit so that a later design change is not confused with an upstream instruction change.

The adapter layer is a small Cursor rule that tells the agent when to read the skill and what application constraints remain binding. This is an instruction adapter, not an MCP server. It exposes no tools and creates no runtime sandbox.

The application layer contains the actual components, tokens, routes, and tests. It remains the source of truth for behavior.

Keep model transport separate as well. A relay can affect response latency or model availability, but it cannot establish whether a layout is usable.

One reproducible setup

Run this from the application repository root. It requires Git, Python 3, and Node.js 18 or newer. It deliberately stops if the repository contains multiple skill entry points rather than guessing which one to use.

The same block creates an optional HTTP baseline probe using B-Lost's relay endpoint. That probe is independent of Cursor; it does not override Cursor's model settings.

set -eu

mkdir -p .cursor/vendor .cursor/rules scripts

if [ ! -d .cursor/vendor/hallmark/.git ]; then
  git clone https://github.com/Nutlope/hallmark.git \
    .cursor/vendor/hallmark
fi

git -C .cursor/vendor/hallmark rev-parse HEAD \
  > .cursor/hallmark.commit

python3 - <<'PY'
from pathlib import Path
import subprocess

root = Path(".cursor/vendor/hallmark")
tracked = subprocess.check_output(
    ["git", "-C", str(root), "ls-files"], text=True
).splitlines()
skills = [p for p in tracked if Path(p).name == "SKILL.md"]

if len(skills) != 1:
    raise SystemExit(
        "Expected one SKILL.md; inspect the repository and select "
        f"an entry point explicitly. Candidates: {skills}"
    )

skill = (root / skills[0]).as_posix()
rule = f"""---
description: "Explicit Hallmark design review"
alwaysApply: false
---

Before a design review, read `{skill}` and any supporting files
it requires. If unavailable, stop and report that limitation.

Use its visual guidance within these application constraints:
- Preserve existing functionality, labels, and keyboard behavior.
- Reuse established components and tokens unless asked to replace them.
- Do not add dependencies without approval.
- Limit changes to the requested screen.
- Describe visual changes separately from functional changes.
- Report browser validation as unverified unless actually performed.
"""
Path(".cursor/rules/hallmark-review.mdc").write_text(rule)
PY

cat > scripts/relay-baseline.mjs <<'JS'
import { performance } from "node:perf_hooks";

const config = {
  baseURL: "https://b-lost.com/v1",
  apiKey: process.env.BLOST_API_KEY,
  model: process.env.BLOST_MODEL,
};

if (!config.apiKey || !config.model) {
  throw new Error("Set BLOST_API_KEY and BLOST_MODEL.");
}

const start = performance.now();
const response = await fetch(`${config.baseURL}/chat/completions`, {
  method: "POST",
  signal: AbortSignal.timeout(60_000),
  headers: {
    Authorization: `Bearer ${config.apiKey}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: config.model,
    messages: [{ role: "user", content: "Reply with OK." }],
    max_tokens: 16,
    stream: false,
  }),
});

console.log(JSON.stringify({
  status: response.status,
  elapsedMs: Math.round(performance.now() - start),
}));

if (!response.ok) process.exitCode = 1;
JS
Enter fullscreen mode Exit fullscreen mode

Review the downloaded instructions before invoking them. Repository content is still external input, even when packaged as a skill. Pinning records provenance; it does not establish trust.

Diagnose the design pass, not just the request

In Cursor, explicitly attach the hallmark-review rule through the rule picker. Request one bounded change: improve hierarchy on one existing screen without changing its behavior.

Save a baseline screenshot first. Use the same viewport, route, content, and application state afterward. Otherwise, a different data fixture can masquerade as a design improvement.

For a concrete acceptance budget, require zero removed form labels, zero unintended keyboard-order changes, zero new dependencies, and changes confined to the requested screen. These are proposed gates, not measured Hallmark results.

Compare the Git diff with the screenshots. If a "visual refinement" changes submission logic, the integration has crossed its boundary.

The relay probe provides a separate diagnostic. Set BLOST_API_KEY and a model identifier supported by your account, then run node scripts/relay-baseline.mjs. It reports HTTP status and request-to-headers latency. It does not measure complete generation latency, design quality, or Cursor performance.

Do not attribute a failed IDE request to Hallmark because a relay probe also failed; those are different execution paths.

The trade-off is deliberate friction

Manual activation adds a step. It also prevents design instructions from influencing dependency updates, bug fixes, and routine component maintenance.

Vendoring introduces update work and a nested Git checkout. Record the resolved revision in the parent repository, and have CI or onboarding restore that exact revision rather than cloning whichever commit happens to be current.

Finally, a skill cannot guarantee originality. It can redirect an agent's attention, but application constraints and visual inspection still decide whether the result belongs in production.

Hallmark is most useful as bounded design guidance: explicitly invoked, revision-controlled, and evaluated against the interface it actually changes.


The hardest part is not integrating the skill. It is deciding when visual novelty justifies diverging from an established component library, and when "distinctive" becomes a liability for users who depend on consistent interaction patterns.

How do you balance design exploration with interface stability in AI-assisted workflows? What boundaries have you drawn, and where did they fail?

Top comments (0)