claudeers.
// Claude Skills

oxfords

UI/UX skill for Claude Code, Codex and Cursor. Polished, plain interfaces with no AI slop. Includes a zero-dependency slop checker.

// Claude Skills[ cli ][ api ][ desktop ][ mobile ][ claude ]#claude#accessibility#agent-skills#ai-agents#ai-slop#claude-code#claude-skills#codex#skills◷ MIT$open-sourceupdated 20 days ago
Actively maintained
100/100
last commit 16 days ago
last release 16 days ago
releases 2
open issues 0

Install with your AI

Paste into Claude Code, Cursor, or any agent — it reads the repo and wires the tool into your project.

Install and set up oxfords (release-binary project) into my current project.
Found on https://claudeers.com/oxfords
Repo: https://github.com/arhamhi/oxfords
Homepage/docs: —
Detected install method: release-binary → inspect the README
Category: skills. Platforms: cli, api, desktop, mobile.
Read the repo's README for exact setup and env vars, then install it and wire it into my project.

Claudeers Health Verdict:
active; community-verified: false. Confirm the source before running anything.
// or install directly (release-binary)

Grab the latest release asset from GitHub.

# download a build from https://github.com/arhamhi/oxfords/releases
// or clone
git clone https://github.com/arhamhi/oxfords

// compatibility

Platformscli, api, desktop, mobile
Operating systems—
AI compatibilityclaude
LicenseMIT
Pricingopen-source
LanguageJavaScript

Get your FREE $2.50 API credits to access TickAtlas financial data ↗

Oxfords

Your AI builds UIs that look like someone actually finished them.
A UI/UX skill for Claude Code, Codex and Cursor. Polished, plain, no AI slop.


Oxfords, not brogues. An Oxford is the plain shoe, and a brogue is the same shoe with a bunch of decoration punched into it.

So this skill won't make your site look insane, and it won't give you crazy animations. There are good skills for that already. What I wanted was the boring part done properly: a screen that's clear, that's finished, and that doesn't have the stuff on it that tells everyone an AI made it.

Oil painting of a plain pair of oxford shoes against a pale wall

A restaurant dashboard built with no skill, then redesigned with Oxfords

A dashboard built with no skill, then redesigned with Oxfords. Same data, same labels, same links.

What you get

The half that gets skipped. AI builds the happy path and then stops. Oxfords makes it keep going, so you get the button states, the feedback when you click something, the empty screen, the error screen, what happens with a really long name or 10,000 rows, keyboard focus, and tap targets that work on a phone.

A screen you can actually scan. Nobody reads a UI. You land on it with one question and you hunt for the answer. So Oxfords lines things up on edges, lets the data decide what component to use, and makes one thing on the screen important instead of all of it.

No AI slop. I kept seeing the same tells in everything AI builds, even with good design skills loaded, so there's a strict list of them and what to use instead:

OutIn
A coloured bar down the side of the active nav itemA full-row fill
A card around everything, cards inside cardsSpace, alignment, one hairline
A small uppercase label above every headingThe heading
Inter, Geist, Poppins, Instrument Serif, PlayfairThe system font, or a face you can give a reason for
Emoji as icons, the stock icon set at default strokeOne icon set, one weight, matched to the text
Bone and orange, white and blue, purple gradientsA palette chosen for the product, with a reason
Gradient text, glowsFlat colour, and each colour does one job
A tinted pill on every statusColour only where something needs attention
Bounce, fade-up on everything, pulsing dotsShort ease-out transitions that explain a change
"Seamless", "Get started", Acme, 99.9%The plain sentence and believable data

Colours somebody actually picked. You've probably noticed Claude goes for the same bone background with an orange accent on pretty much everything now. Before that it was purple gradients, and if you tell it to be "clean" you get white, grey and one blue button. They're all the same problem, the colour got picked by default. So Oxfords comes with 26 palettes, three colours each, and the agent has to choose one for your product and say why. The palette goes on top of proper neutrals though, white, black and greys still do most of the work, so you don't end up with a page that's cream from edge to edge.

And the agent doesn't type colours by hand anymore. A script turns the palette into every colour the page needs: the hover and pressed shades, a version of each colour that's actually readable as text, three levels of grey for text, red for delete that never gets mixed up with your brand, and a dark mode that's designed instead of just flipped. Every pair is contrast checked before it's written. Got a client colour? Give it that and it builds the rest around it.

node skills/oxfords/scripts/palette.mjs Tideline --mode both
node skills/oxfords/scripts/palette.mjs --brand "#FF8A3D"

The Oxfords palettes, each shown as lead, support and pop colour on a white or black card

Checkers, so it's not just vibes. The first one reads your code, no dependencies:

node skills/oxfords/scripts/check.mjs ./src
src/components/Sidebar.tsx
  FAIL  accent-rail          coloured bar on the side of an element; use a full fill or nothing  (line 42)
        border-left: 3px solid
  FAIL  default-font         default font nobody chose; use the system stack or a face with a stated reason  (line 7)
  WARN  viewport-100vh       100vh jumps on phones; use dvh or svh  (line 18)

1 file, 2 fail, 1 warn

It exits with an error when something fails, so you can put it in CI or a pre-commit hook.

The second one actually opens the page. It renders it on a phone width and a desktop width, in light and dark, saves the screenshots, and measures the stuff you can't see in code: text that fails contrast, text that's clipped or overlapping, sideways scrolling, focus you can't see, buttons too small to tap, and how much of the screen is colour. It needs Playwright, and if you don't have it, it tells you and gets out of the way.

node skills/oxfords/scripts/shoot.mjs ./dist/index.html

Install

Claude Code, Codex and other agents that read skills

npx skills add arhamhi/oxfords

Or copy skills/oxfords into your skills folder (~/.claude/skills/ for Claude Code, ~/.agents/skills/ for Codex and others).

Cursor

Copy skills/oxfords into your project and adapters/cursor/oxfords.mdc into .cursor/rules/.

Anything that reads AGENTS.md

Copy skills/oxfords into your project and paste adapters/AGENTS.md into your AGENTS.md.

Use

You don't have to do anything special. Ask for UI work the way you already do and the skill loads when the task is a UI.

Build the orders dashboard.
Review this settings page with oxfords.
This looks AI-generated. Fix it.

It works in four modes:

ModeWhat happens
BuildReads the brief, works a twelve-step build order from intent to finished states, measures the result and fills a done gate
RedesignWrites down what has to stay first (links, labels, fields, data), then redesigns, then proves nothing went missing
ReviewLooks at the screenshots first, measures second, reports each finding as symptom, fix and reason
FixChanges only what a finding names and leaves your copy and identity alone

What is inside

skills/oxfords/
  SKILL.md                       build order, done gate, slop floor, numbers
  references/
    app-ui.md                    dashboards, tables, charts, settings
    mobile.md                    app screens, navigation, sheets, gestures
    landing.md                   message, structure, what to leave out
    redesign.md                  what to keep, what to change, in what order
    states-forms-copy.md         every state, forms, errors, copy, accessibility
    colour.md                    neutrals, palettes, states, dark mode, client colours
    slop-floor.md                the full ban list with replacements
    motion.md                    timing, easing, gestures, reduced motion
    review.md                    fresh eyes, the two passes, severity, when to stop
  scripts/
    palette.mjs                  turns a palette into every colour token, contrast checked
    palettes.json                the 26 palettes
    check.mjs                    the slop checker, reads code
    shoot.mjs                    the render check, opens the page and measures it
    keep.mjs                     checks a redesign kept every link, label and field

The main file is short on purpose. Your agent reads it every time, and only opens a reference file for the thing it's actually building.

What Oxfords is not

  • It won't replace your brand. If your project already has colours or a design system, those win. The palettes are for when you've got nothing.
  • It won't give you a look. If you want a landing page with a signature animation, use a design skill built for that and let Oxfords check the result after.
  • It can't see everything. The render check measures contrast, clipping and focus, but it can't tell you've put a card inside a card or a button that does nothing. Those are on a short list you check by eye.

One thing I had to be careful with: plain doesn't mean empty. If you strip all the slop out and add nothing, you get a grey page with one accent colour, and that's just a different kind of generic. So Oxfords asks for real content, one clear thing to look at first, and choices you can give a reason for.

How it was tested

I froze a copy of v1 and a copy of v2, wrote four briefs that each push on something different, and had the same model build every brief twice, once with each version. The briefs are a dark dispatch board for an HVAC company, a landing page that has to use a client's orange, a settings screen in light and dark, and a redesign of an existing screen that has to keep its labels and links.

Then a fresh judge on a different model got the brief and the screenshots and nothing else. The two builds were labelled X and Y in a random order, it scored seven things out of 5 and picked one. I only unblinded once all four had answered.

                      judge picked   points, v1 / v2     checker warnings, v1 / v2
dispatch board        v2             19 / 28             6 / 0
landing page          v1             29 / 23             0 / 0
workspace settings    v2             27 / 29             42 / 0
redesign              v2             24 / 29             1 / 0

v2 won three out of four, and every judge that picked it gave colour as a reason: states that mean something, the client's brand kept as the brand, delete in red. The landing page went to v1 and the judge was right. The v2 build put a muddy brown card where the price lives and built the hero like an app with tabs and a chart, when v1 just showed the report the clinic actually gets. The brown was a bug in the colour engine and that's fixed. Everything else the judges flagged, on either side, is a rule in the skill now.

That's 22 rule changes I haven't re-run yet, so treat this as one round. One judge per brief, one judge model, four briefs, and 29 to 27 on settings is close to a coin flip. One judge also said a link failed contrast when it measures 5.18:1, so the judges get things wrong too.

The dispatch board brief built with Oxfords v1, then v2

The workspace settings brief built with Oxfords v1, then v2

Every brief and both builds of it are in docs/test-run (old.html is v1, new.html is v2), so you can run the checkers on them yourself:

node skills/oxfords/scripts/check.mjs docs/test-run/settings/old.html
node skills/oxfords/scripts/shoot.mjs docs/test-run/settings/old.html

oxfords

Credits

I didn't come up with most of this. The usability side I learned from Kole Jain's videos, and you should watch them. I also studied impeccable by Paul Bakaus, taste-skill by Leonxlnx, and apple-design by Emil Kowalski, and took ideas from each. Everything here is written in my own words, and what came from where is in CREDITS.md.

The paintings in this repo were made in code, stroke by stroke. They're all in art.

Licence

MIT. See LICENSE.

// faq

What is oxfords?

UI/UX skill for Claude Code, Codex and Cursor. Polished, plain interfaces with no AI slop. Includes a zero-dependency slop checker.. It is open-source on GitHub.

Is oxfords free to use?

oxfords is open-source under the MIT license, so it is free to use.

What category does oxfords belong to?

oxfords is listed under skills in the Claudeers registry of Claude-compatible tools.

8 views
★ 27 stars
unclaimed
updated 20 days ago

// embed badge

oxfords on Claudeers
[![Claudeers](https://claudeers.com/api/badge/oxfords.svg)](https://claudeers.com/oxfords)

// retro hit counter

oxfords hit counter
[![Hits](https://claudeers.com/api/counter/oxfords.svg)](https://claudeers.com/oxfords)

// reviews

// guestbook

0/500

// related in Claude Skills

🔓

An agentic skills framework & software development methodology that works.

// skillsobra/⟨Shell⟩★ 314,126◷ MIT[ claude ]
🔓

Public repository for Agent Skills

// skillsanthropics/⟨Python⟩★ 188,182[ claude ]
🔓

AI coding assistant skill (Claude Code, Codex, OpenCode, Cursor, Gemini CLI, and more). Turn any folder of code, SQL schemas, R scripts, shell scripts, docs,…

// skillsGraphify-Labs/⟨Python⟩★ 149,064◷ MIT[ claude ]
🔓

💫 Toolkit to help you get started with Spec-Driven Development

// skillsgithub/⟨Python⟩★ 148,200◷ MIT[ claude ]
→ see how oxfords connects across the ecosystem