SkillAgentSearch skills...

super-ui-ux-design

Complete UI/UX design capability — a wiki-style knowledge map of design theory (UX laws, Nielsen heuristics, usability, visual hierarchy, typography, contrast/WCAG, design systems, aesthetics-vs-conversion) fused with a hands-on execution playbook for building distinctive, production-grade frontend…

Install / Use

npx skills add syahiidkamil/Software-Engineer-AI-Agent-Atlas --skill super-ui-ux-design

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

91/100

Category

Design

Supported Platforms

Universal

Our assessment of super-ui-ux-design

super-ui-ux-design scores 91/100 on our quality scale, 64th of 260 Design skills we index (top 25%).

Its SKILL.md is 35 KB long, well organised into 41 sections with 10 code examples: a thorough specification that gives an agent plenty to work with.

It has 406 GitHub stars, a meaningful sign that others use it.

Substance
30/30
Structure
20/20
Description
15/15
Adoption
11/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 15 days ago, so super-ui-ux-design is actively maintained.
  • No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
  • Its trust signals score 88/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-11-13. Automated pattern scan on 2026-11-13. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

super-ui-ux-design compared with similar skills

All 4 of these similar skills score higher than super-ui-ux-design; compare them before choosing.

SkillScoreStarsUpdatedFormat
super-ui-ux-design (this skill)by syahiidkamil9140615d agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
Claude-Code-Game-Studiosby Donchitos10039.7k7d agoCLAUDE.md
x402by browser-use100121.0k3d agoSKILL.md
algorithmic-artby anthropics100177.9k55d agoSKILL.md

Frequently asked questions

How do I install super-ui-ux-design?
Run npx skills add syahiidkamil/Software-Engineer-AI-Agent-Atlas --skill super-ui-ux-design. The install tabs above show the steps for each supported agent.
Which AI agents does super-ui-ux-design work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is super-ui-ux-design safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 88/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is super-ui-ux-design still maintained?
The repository was last updated 15 days ago, so super-ui-ux-design is actively maintained.

name: super-ui-ux-design description: Complete UI/UX design capability — a wiki-style knowledge map of design theory (UX laws, Nielsen heuristics, usability, visual hierarchy, typography, contrast/WCAG, design systems, aesthetics-vs-conversion) fused with a hands-on execution playbook for building distinctive, production-grade frontend interfaces. Use when designing or building any UI (websites, landing pages, dashboards, components, apps), reviewing or critiquing UI/UX, diagnosing why a design doesn't convert, or styling/beautifying web interfaces. Grounds every visual decision in UX principles and avoids generic AI aesthetics. license: Complete terms in LICENSE.txt original_source: Execution playbook modified from anthropics/claude-code-skills (frontend-design), licensed under Apache 2.0

📐 The Full Schemata of UI/UX Design

A wiki-style knowledge map. Each section is a node. Follow the links, build the schema in your head, then go break it against real users.

Format notes: Internal links like Visual Hierarchy jump between nodes. Mermaid blocks render in Obsidian, GitHub, Notion, and most modern markdown viewers.


🗺️ The Master Map

Start here. Everything below hangs off this tree.

mindmap
  root((DESIGN))
    Problem Solving
      Define the problem
      Constraints
      Trade-offs
      Iteration
    UX["UX (Experience)"]
      Research
      Information Architecture
      Interaction Design
      Usability
      Mental Models
      UX Laws & Heuristics
    UI["UI (Interface)"]
      Visual Hierarchy
      Layout & Grids
      Typography
      Color & Contrast
      Components
    Design Systems
      Tokens
      Components
      Patterns
      Documentation
    Business Layer
      Conversion
      Retention
      Trust & Credibility
      Aesthetics vs Performance
    Learning Layer
      Constructivism
      Schemata
      Mental Models
      Jakob's Law

🧩 Node 0 — What Is Design?

Definition: Design is the intentional shaping of something (a product, a screen, a service, a process) to achieve a purpose under constraints.

The keyword is intentional. Decoration happens to look nice. Design exists to do something.

Herbert Simon, in The Sciences of the Artificial, framed it roughly as: anyone who devises a course of action to change an existing situation into a preferred one is designing. By that definition, a doctor writing a treatment plan is designing. So is an engineer, a teacher, and yes, the person arranging buttons on a checkout page.

So... is design about problem solving?

Yes, with one important nuance.

Design is problem solving, but it's a specific flavor of it. Most design problems are what theorists call wicked problems (Rittel & Webber, 1973):

  • There is no single correct answer, only better and worse ones
  • The problem definition itself shifts as you work on it
  • Every solution creates new constraints
  • You can't fully test a solution without shipping it

This is why design is iterative by nature. You don't "solve" a checkout flow the way you solve a math equation. You propose, test, learn, and revise.

flowchart LR
    A[Existing Situation] -->|"Understand the problem"| B[Problem Definition]
    B -->|"Generate options"| C[Proposed Solution]
    C -->|"Test with reality"| D{Did it work?}
    D -->|"No / Partially"| B
    D -->|"Yes"| E[Preferred Situation]
    E -.->|"World changes, new problems"| A

⚠️ The nuance: "Design = problem solving" is true but incomplete. Design also involves problem finding (framing what's actually wrong) and meaning making (why should anyone care?). A perfectly solved wrong problem is still a failure.

See also: The Double Diamond, Wicked problems vs puzzles


🧠 Node 1 — Constructivism & Schemata (Why This Document Is Shaped Like This)

You asked about Constructivism and schemata. Both matter twice here: once for how you learn design, and once for how your users experience your design.

Constructivism (the learning theory)

Definition: Knowledge isn't transferred into your head like a file copy. You construct it by connecting new information to what you already know. Key figures: Jean Piaget (cognitive constructivism), Lev Vygotsky (social constructivism).

Piaget's two core mechanisms:

| Mechanism | What happens | Design-learning example | |---|---|---| | Assimilation | New info fits into an existing schema | "Oh, a design token is just a variable. I know variables." | | Accommodation | New info breaks the schema, forcing you to rebuild it | "Wait, beautiful design lowered conversion? My schema 'pretty = good' is wrong." |

Schemata (the mental structures)

Definition: A schema (plural: schemata) is an organized mental framework: a cluster of related concepts, expectations, and patterns. The term comes from Piaget and from Frederic Bartlett's memory research (1932).

A wiki is basically a schema made visible. Nodes, links, hierarchy. That's why this document is wiki-shaped: the format mirrors the cognitive structure you're trying to build.

The bridge to UX: users have schemata too

Here is the punchline. In UX, a user's schema is called a mental model, and it's one of the most powerful forces in interface design.

flowchart TD
    A["Schema Theory<br/>(Piaget, Bartlett)"] --> B["Mental Models<br/>(how users THINK a system works)"]
    B --> C["Jakob's Law<br/>'Users spend most of their time on OTHER sites'"]
    C --> D["Design implication:<br/>Match conventions unless you have<br/>a very good reason not to"]
    B --> E["Norman's Gulf of Execution<br/>(user can't figure out HOW to act)"]
    B --> F["Norman's Gulf of Evaluation<br/>(user can't tell WHAT happened)"]
    E --> G[Confusion, abandonment]
    F --> G

When your interface matches the user's schema, it feels "intuitive." When it violates the schema, the user must accommodate (rebuild their mental model), and accommodation costs effort. Users mostly refuse to pay that cost. They just leave.

💡 Rule of thumb: "Intuitive" is not a property of your design. It's a property of the match between your design and the user's existing schemata.

See also: UX Laws, Why ugly sites convert


🔀 Node 2 — UI vs UX (They Are Not the Same Thing)

UX (User Experience): The entire journey: how someone discovers, learns, uses, struggles with, and feels about a product. UX includes things you never see on screen: loading speed, support emails, the pricing page, the cancellation flow.

UI (User Interface): The concrete surface a person touches: screens, buttons, typography, colors, spacing, motion.

A classic way to relate them:

flowchart TB
    subgraph UX["UX — the whole experience"]
        direction TB
        R[Research & Strategy] --> IA[Information Architecture]
        IA --> IXD[Interaction Design]
        IXD --> UI_node
        subgraph UI_node["UI — the visible surface"]
            V[Visual Design]
            T[Typography]
            C[Color & Contrast]
            CO[Components]
        end
        IXD --> U[Usability Testing]
        U --> R
    end

Common metaphor: UX is the architecture and structural engineering of a house; UI is the interior finishing. A gorgeous interior in a house with no plumbing is still a bad house. (And yes, the metaphor leaks: in practice UI decisions feed back into UX. The layers talk to each other.)

| | UX | UI | |---|---|---| | Core question | Does this solve the right problem, smoothly? | Is this clear, legible, and pleasant to operate? | | Artifacts | Personas, journey maps, flows, wireframes, test reports | Mockups, design systems, components, prototypes | | Measured by | Task success, time on task, retention, NPS, support tickets | Legibility, scannability, error rate per screen, accessibility | | Fails like | "I don't understand what this app is for" | "I can't read this gray text on white" |

See also: Usability, Visual Hierarchy


🏛️ Node 3 — The Principles of UX

You asked directly: what is the principle of UX? There isn't one principle; there are a few canonical frameworks. Learn these three and you've covered most of the field's foundations.

3.1 Don Norman's design principles (The Design of Everyday Things)

  1. Visibility — Can the user see what actions are possible?
  2. Feedback — Does the system respond to every action, immediately and clearly?
  3. Affordances — Does the object's form suggest how to use it? (A handle affords pulling.)
  4. Signifiers — Explicit signals of where to act (a "Push" label, an underlined link)
  5. Mapping — Does the control's layout match its effect? (Stove knobs arranged like the burners.)
  6. Constraints — Does the design prevent wrong actions? (Grayed-out buttons, plugs that only fit one way.)
  7. Conceptual model — Does the user end up with an accurate schema of how the system works?

3.2 Nielsen's 10 Usability Heuristics (1994, still the industry standard)

  1. Visibility of system status
  2. Match between system and the real world
  3. User control and freedom (undo, escape hatches)
  4. Consistency and standards
  5. Error prevention
  6. Recognition rather than recall
  7. Flexibility and efficiency of use (shortcuts for experts)
  8. Aesthetic and minimalist design
  9. Help users recognize, diagnose, and recover from errors
  10. Help and documentation

💡 Memorize #6. "Recognition rather than recall" explains half of all good UI decisions: show options instead of making users remember them. It's schema theory in action: recognition only requires activating an existing schema; recall requires reconstructing one.

3.3 The UX Hierarchy of Needs

Borrowed from Maslow. You cannot skip levels. Delight built on broken functionality is lipstick on a 404.

flowchart BT
    A["1. FUNCTIONAL<br/>It works. No crashes, no dead ends."] --> B["2. RELIABLE<br/>It works consistently, every time."]
    B --> C["3. USABLE<br/>It works without a manual."]
    C --> D["4. CONVENIENT<br/>It fits into my life and habits."]
    D --> E["5. PLEASURABLE<br/>It feels good. I'd recommend it."]
    E --> F["6. MEANINGFUL<br/>It matters to my identity or values."]

See also: Usability, Aesthetics vs Conversion


⚖️ Node 4 — The Laws & Heuristics of UX

These are the empirical regularities of human-computer interaction. Treat them like physics for interfaces. (Reference: lawsofux.com)

| Law | Statement | Practical move | |---|---|---| | Jakob's Law | Users spend most of their time on other products, so they expect yours to work the same way | Follow conventions for nav, carts, forms. Innovate on value, not on where the logout button lives | | Hick's Law | Decision time grows with the number and complexity of choices | Cut options. One primary CTA per screen. Progressive disclosure for the rest | | Fitts's Law | Time to hit a target depends on its distance and size | Make tap targets big (44×44px+) and put frequent actions within thumb reach | | Miller's Law | Working memory holds about 7±2 chunks | Chunk phone numbers, group form fields, break long flows into steps | | Tesler's Law | Every system has irreducible complexity; someone must absorb it | Absorb complexity in the design, not in the user. Smart defaults > 12 settings | | Aesthetic–Usability Effect | People perceive attractive designs as more usable, even when they aren't | Beauty buys forgiveness for small flaws. It also masks real flaws in testing. Double-edged 🔪 | | Von Restorff Effect | T

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars406
CategoryDesign
Updated15d ago
Forks60

Languages

JavaScript

Trust signals

88/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 medium