Skip to content
Skills Library
Design & UX · Review & audit

design-patterns

/design-patterns

Replace generic interface choices with patterns justified by the user's task, content and product constraints. Use for a visual redesign, a UI critique or a request to make a screen less templated; excludes backend architecture and software design patterns.

Repository
dusk_code ↗
Licence
MIT
Last repository change
13.11.2026

Assessment and security

95/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content30 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 13.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Replace generic interface choices with patterns justified by the user's task, content and product constraints. Use for a visual redesign, a UI critique or a request to make a screen less templated; excludes backend architecture and software design patterns.

Original author description

Replace generic interface choices with patterns justified by the user's task, content and product constraints. Use for a visual redesign, a UI critique or a request to make a screen less templated; excludes backend architecture and software design patterns.

How it works

  1. Establish the decision surface
  2. Keep a small defect ledger
  3. Match the pattern to the work
  4. Express hierarchy consistently
  5. Judge the result in use
Original SKILL.md headings · 92 lines, 790 words
SKILL.md preview
---
name: design-patterns
description: Replace generic interface choices with patterns justified by the user's task, content and product constraints. Use for a visual redesign, a UI critique or a request to make a screen less templated; excludes backend architecture and software design patterns.
source: "dusk_code"
author: "Neil Ermak"
license: MIT
---

# Design Patterns

Make the interface explain its purpose through its organization and behavior.
An unusual font or a different accent cannot repair a screen whose structure hides
the work people came to do. Choose patterns by the information and decisions they
support, then give those patterns a coherent visual language.

## Establish the decision surface

Identify the screen, intended audience, most frequent task, and the consequence of
an incorrect action. Read the existing components and theme before proposing a
replacement. Preserve the user's chosen style, content, workflows and public
interfaces unless changing them belongs to the request.

Use real content lengths and representative data. For a monitoring console, ask
which signal deserves investigation; for a catalog, which attributes distinguish
items; for a form, what information a person needs before committing. These
answers determine prominence and grouping more reliably than a trend board.

If the input is an image or a public URL without editable source, separate a
critique or proposed implementation from changes to the original product. A
reconstruction is a new artifact and cannot establish the original's behavior.

## Keep a small defect ledger

For each material problem record: location, visible symptom, effect on a task,
proposed correction, and how it can be checked. Prioritize lost information,
ambiguous actions and inaccessible controls before decorative differences.
Distinguish an observed defect from a preference or an untested hypothesis.

Treat repeated card containers, competing accents, uniform type emphasis and
ornamental labels as questions to investigate. They are not automatic defects.
A familiar component is appropriate when it helps people recognize an action.
If the current design works, report that finding and limit edits to demonstrated
problems rather than manufacturing a redesign.

## Match the pattern to the work

| Information relationship | Candidate arrangement | Check before choosing |
|---|---|---|
| Many records compared by the same attributes | Aligned rows with shared headings | Can people scan one attribute without opening each record? |
| One decision requires supporting context | Main workspace beside an inspector | Does the selected item remain visible while details change? |
| A long task has dependent inputs | Sections with a persistent completion summary | Can people revise earlier input without losing later work? |
| Events must be interpreted over time | Time-based grouping with explicit units | Are gaps, ordering and time zones unambiguous? |
| A visitor needs to understand an unfamiliar service | Concrete demonstration beside a concise explanation | Is the demonstration truthful and readable at the intended size? |

These are candidates, not a mandatory template collection. Compare alternatives
only where the tradeoff matters. Record the chosen organization, the content
that earns emphasis, and the constraints it must survive. Proceed within existing
authorization; ask only when a missing decision would materially change scope.

## Express hierarchy consistently

Derive spacing from content groups and repeated alignment anchors. Use the
project's tokens where possible; introduce a new token only for a repeated role.
Distinguish body text, navigation, headings and quantitative values through their
reading needs. Verify line wrapping with actual strings, including localization.

Assign color a job: selection, status, grouping or brand recognition. A status
must remain understandable without color alone. Choose imagery for explanatory
value and available rights. Do not add a remote font, asset service, dependency
or generated image merely to make the result look different.

Write action labels around the resulting user operation. Keep the same operation
named consistently across controls and feedback. Preserve useful context in
empty, pending, failed and completed states. Animate only when the transition
helps someone understand a change, and respect reduced-motion preferences.

Apply the smallest coherent set of changes that resolves the ledger. Reuse
existing components and interaction contracts. Avoid broad framework or component
rewrites as a side effect of visual work.

## Judge the result in use

When execution is available, inspect the rendered screen at representative wide
and narrow sizes. Walk the primary task with keyboard and pointer, check focus
visibility, and exercise relevant loading, empty and error states. Verify zoom,
overflow and long content where they can affect the changed screen. For terminal
interfaces, inspect the actual terminal at representative dimensions; a browser
preview does not prove terminal input or layout behavior.

Compare each ledger item with the resulting screen and its interaction. Run the
project checks appropriate to the implementation. If a browser, terminal, service
or test account is unavailable, state the unverified behavior specifically;
source inspection and compilation do not establish visual or interaction quality.

Deliver the changed artifacts, the reasoning behind the consequential choices,
the observed checks, and unresolved ledger items. Include useful before/after
captures when available without exposing private data. Stop when the requested
outcome is evidenced; extra decoration is not an acceptance criterion.

Versions

RepositoryScoreLicence
This page · DroBov1Tya/dusk_code95MIT
spencerbeggs/effected100MIT
spencerbeggs/effected100MIT
joeblackwaslike/agent-skills100MIT
krzysztofsurdy/code-virtuoso100MIT
nimadorostkar/Claude-Skills-collection100MIT
andreibesleaga/gabbe100CC-BY-4.0
pantheon-org/tekhne100MIT
itzcull/software-skills100MIT

Database snapshot: 13.11.2026 · package version aca98679fcd4 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100ui-design
    Unify product UI design, frontend implementation, and verification. Use when asked to design, redesign, build, or fix a web, desktop, or mobile interface; a page, dashboard, form, component, design system, responsive layout, accessibility, interface animation, or editable…
  • 100design-quality
    Use for ANY work that changes how a UI looks: a new app/site/screen, a theme or redesign, a new logo or app icon, a new component, or even a small UI fix inside an existing product (player, reader, dashboard). Two modes: PRESERVE (editing an existing product — keep its design…
  • 100interface-refinement
    Refine an existing interface with named commands (critique, polish, distill, typeset, colorize ...), a product and design context file, and a static detector of generic UI patterns. Use when UI looks generic, cluttered or unfinished.
  • 100ai-design-tells
    Identify and fix generic AI design patterns in websites, landing pages, portfolios, and product interfaces. Use for requests about AI design tells, AI slop, a vibe-coded appearance, templated layouts, or preventing generic design during a build. Supports visual audits, focused…
  • 100screen-flow-patterns
    Taxonomy of 25+ screen types, 15+ user flows, and 25+ UI element deep-dives with layout patterns, component hierarchies, state matrices, and best-in-class references. Use when deciding which screens a product needs and what connects them, before any visual design starts.
  • 90product-interface-design
    Use when product feature design, multi-screen experience or high-fidelity interaction specification. Translate flows and constraints into polished implementable UI screens and interactions. Do not use when only writing backend code with no UI impact.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.