laws-of-taste
Laws of Taste
Apply this skill to any visual surface people must look at, scan, use, trust, or move through.
Core stance
Taste is not decoration. Taste is the disciplined shaping of attention, meaning, rhythm, and feeling.
Default to these beliefs:
- Purpose before ornament.
- Order before expression; then break order intentionally.
- Hierarchy must be obvious at a glance.
- Restraint beats novelty unless novelty is the point.
- Systems create trust; selective exceptions create life.
- The goal is not “more design.” The goal is inevitability: this feels like the right form for the content, brand, audience, and medium.
This skill is intentionally opinionated. It should not rubber-stamp generic work. If something feels templated, muddy, loud without reason, or visually unserious, say so plainly and improve it.
When to use
Use this skill when the user asks to:
- make a UI, site, app, dashboard, deck, document, or visual brand surface feel better
- improve the taste, polish, feel, readability, sophistication, or visual clarity of something
- redesign or refine a front end, component library, design system, or visual surface
- make something feel more premium, editorial, modern, sharp, timeless, warm, or confident
- review visual hierarchy, spacing, typography, color, imagery, motion, or overall coherence
- adapt the same taste principles across print and digital contexts
Do not use this skill for:
- backend, infrastructure, database, or algorithm work with no visual surface
- copyediting-only writing tasks
- naming-only or positioning-only brand strategy
- generic productivity advice that has no visual output
Operating order
Always work in this sequence unless the task clearly demands another order:
-
Find the job of the surface
- What is this thing trying to help a person do?
- What must be noticed first, second, and third?
- Is this for scanning, reading, comparing, deciding, buying, trusting, or delighting?
-
Diagnose the real visual problem Describe the issue in design terms, not vibes:
- weak hierarchy
- no governing structure
- muddy grouping
- unconvincing type
- decorative but meaningless color
- too many competing focal points
- inconsistent rhythm
- generic components
- flat or lifeless motion
- responsive collapse
- polished parts, incoherent whole
-
Choose a design thesis Pick one sentence that governs the redesign. Examples:
- “Make the interface calmer by strengthening order and reducing simultaneous emphasis.”
- “Make the product feel more premium by increasing typographic confidence and subtracting chrome.”
- “Make the dashboard faster to read by reducing visual noise and concentrating contrast on anomalies.”
-
Apply the laws in order For deep redesigns, audits, unfamiliar surfaces, or any task that needs explicit law-by-law reasoning, read
references/LAWS.md. Then apply:- hierarchy
- structure/grid
- spacing/rhythm
- typography
- color
- shape and components
- imagery/illustration
- interaction and motion
- finish and consistency
-
Make a few strong moves Prefer 3–7 consequential changes over 20 weak tweaks.
-
Explain tradeoffs State what got stronger and what was intentionally restrained.
-
If working in code Move from design intent to implementation:
- tokens
- spacing scale
- type scale
- layout primitives
- component states
- data visualization config
- motion timings
- responsive rules
Non-negotiable behavior
- Never confuse “taste” with “minimalism.” The right answer may be quiet, dense, playful, loud, luxurious, brutal, editorial, or warm. Context decides.
- Never add decoration that weakens clarity.
- Never let all elements shout at once.
- Never use color as a substitute for structure.
- Never let a grid become a cage. Establish order, then bend it on purpose.
- Never recommend fashionable tricks without a reason tied to the surface’s job.
- Never sacrifice accessibility, legibility, responsiveness, or interaction clarity for style.
- Never pretend certainty when the visual artifact is missing. If you cannot inspect the thing, state assumptions and give a strong provisional direction.
- Ask clarifying questions only when missing context would materially change the recommendation. Otherwise, make explicit assumptions and proceed.
How to respond
Choose the lightest format that fits the task. Read references/OUTPUTS.md when you need a response mode or deliverable template you cannot infer from the task itself.
If the user shares a mockup, screenshot, component, repo, URL, or codebase:
- critique what is actually there
- point to specific visual problems
- propose specific improvements
- if useful, rewrite component structure, CSS, tokens, or layout logic
If the user shares no artifact:
- define the likely surface
- state assumptions
- provide an opinionated design direction with concrete defaults
If the response materially changes color, typography, density, motion, or interaction states, read references/ACCESSIBILITY.md before finalizing.
Required standards
Every response from this skill should aim to improve:
- first-glance clarity
- reading path
- perceived quality
- coherence between parts
- emotional tone
- implementation plausibility
Whenever useful, end with a short self-check against:
- Does the surface now have one main idea?
- Is the hierarchy visible at thumbnail, screen, and close-read distance?
- Is the structure felt even if the grid is invisible?
- Does the typography sound like the brand?
- Is color doing real work?
- What got removed?
- What remains too generic?
Reference files — load on demand
Do not read every reference file on every activation. Load the one that matches the task.
references/LAWS.md— the 22 operating laws. Read for deep redesigns, explicit audits, unfamiliar surfaces, or whenever recommendations should be mapped to named laws.references/ENVIRONMENTS.md— adaptation by surface type. Read when the medium is unfamiliar, mixed, or spans multiple environments.references/OUTPUTS.md— response formats and deliverables. Read when choosing between output modes or when the user wants a particular deliverable shape.references/EVALUATION.md— scorecard for audits and polish passes. Read only for QA, audit, acceptance, or final-review tasks.references/ACCESSIBILITY.md— accessibility floor for tasteful design. Read when changing color, typography, motion, dense data views, or interaction states.references/FOUNDATIONS.md— documented basis from the source books. Read only if the user asks why a principle exists or challenges the rationale.references/FORMS.md— optional intake prompts. Read only when context is genuinely too thin to proceed confidently.
More from mylesmcook/mcook-skills
adversarial-review
Use this skill when you need a serious code review, diff review, or implementation-plan review from independent reviewers. In Codex hosts, prefer a fresh Codex subagent for the Codex reviewer; otherwise use the Codex, Claude Code, and Gemini reviewer paths when available. Return a PASS, CONTESTED, or REJECT verdict.
13subagent-driven-development
Use after an implementation plan is approved to execute mostly independent tasks through fresh subagents with scoped context, harness-aware model routing, proportional review gates, and mandatory controller verification.
10brainerd
>
10simple-code
Reduce incidental complexity in code and design. Use when shaping APIs, module boundaries, refactors, tests, naming, and architecture tradeoffs with a bias toward concrete, local, reversible solutions.
7git-it-out
Use this skill when the user explicitly wants final end-of-session closeout and no more branch or PR limbo: proper verification, proper commits, main/mainline landing, push, repo-native merge/release/deploy/publish steps, tracker updates, Entire/checkpoint handling when configured, and a concise handoff. Reach for it on prompts like 'git it out', 'get it out', 'ship this', 'I'm done', 'I'm going to bed', 'take this off my plate', 'finish the session', or 'get this into production'. Do not use it for greenfield implementation, open-ended debugging, broad refactors, or inventing a release process from scratch.
7simplify
Refine recently changed code for clarity, consistency, and maintainability without changing behavior. Use when the user explicitly asks to simplify, clean up, or lightly refactor touched code, reduce local complexity, remove redundancy, improve naming or structure, or make recent edits easier to read while preserving outputs, interfaces, tests, security, and accessibility.
6