Niblet skill

An interface design skill that anchors an agent to your product, with an optional MCP server adding real screens from a catalogue.

  • 87 ★ on the repository
  • Last commit
  • Apache-2.0
Skill

Extended access

Why this level

  • The agent edits interface code in your repository and runs a render check
  • The catalogue key lives in an environment variable and requests go to the external Niblet service
All reasons and checks

pymodel/niblet-skill-mcp

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/niblet

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Extended accessThe tool runs code or makes network calls and only reads external data.

  • The agent edits interface code in your repository and runs a render check
  • The catalogue key lives in an environment variable and requests go to the external Niblet service

This is third-party code. Review the repository files before installing.

What it does

The `niblet` skill keeps an agent from drawing a generic template. Before code it records a short contract: which screen the task is for, which mode (persuade, operate, read or engage with the work), the primary action, reading order and the real states. The interface is then built from components and tokens already in the codebase and closes with a check of the rendered result: a green build without it does not count. The skill works alone with no account or network. There is also the `@pymodel/niblet` package: a local stdio MCP adapter serves five skill documents and two diagnostic tools without a key. With a key the tools `find_ui_references` (one to three real screens for a specific question), `find_ui_materials` (fonts and icons with their license) and `get_design_reference` (colors, typography and components of a chosen screen) become available. Commands such as `craft`, `audit`, `critique` and `polish` are invoked in plain language.

Who it is for. Frontend developers and product designers who ask an agent to build a screen and want it to follow their own system rather than a template.

Good fit when

  • An agent must build the empty and error states of a checkout screen from your project tokens and components
  • The task is vague and you first need a short contract: screen mode, primary action and states
  • A finished screen should be reviewed: ranked findings on hierarchy, density and accessibility
  • You lack a real example of how a particular state or interaction looks and want one to three live screens
  • A new interface needs a font and icons with a recorded license

Not a fit when

  • You want a ready visual style detached from your product: the skill builds on your tokens and components
  • The work is server logic with no interface: the skill covers screen design only
  • You need the screen catalogue without a key: the three catalogue tools require a `niblet_at_…` key

Example request

Use Niblet to design the empty and error states of the checkout screen on the project tokens, then render the result and show what was verified.

Limitations

The skill itself is free and works offline. The catalogue tools require a `niblet_at_…` key from the Niblet account page, put into `NIBLET_TOKEN` and never committed. The local adapter needs Node.js 24.15 or newer. Claude Desktop and claude.ai connect through a custom connector with account sign-in instead of a key. Only web screens carry a design reference. Native apps follow separate rules in `references/native.md`.

How to disable. Delete the `niblet` folder from `~/.claude/skills/` or `~/.agents/skills/`. Remove the server with `claude mcp remove niblet` and revoke the key in your Niblet account.

FAQ

How do I install the skill?

With `npx skills add PyModel/niblet-skill-mcp --skill niblet -y`. Or copy `skill/niblet` into `~/.claude/skills/niblet` or `~/.agents/skills/niblet`, keeping the `references/` and `agents/` folders alongside.

How do I connect the MCP server?

The local adapter without a key: `claude mcp add niblet -- npx -y @pymodel/niblet`. For the catalogue connect `https://niblet-api.pymodel.com/mcp` with an `Authorization: Bearer` header and a key from the account page.

How do I verify the connection?

Call `niblet_status`: it shows the configured origins, whether a key is present without printing it and the API response. Do this before concluding the catalogue is empty.

Which modes does the skill have?

Four: persuade for marketing and pricing, operate for apps and dashboards, read for documentation and articles, experience for portfolios and interactive work. The mode is picked by the job of the screen.

What does the audit command do?

It reviews the chosen screens against their contract: states, accessibility, responsiveness and consistency. For each finding it gives the location, evidence, severity and smallest fix, marking unexercised checks separately.

Discussion

No questions or reviews yet.

Skills

A UI design skill: art direction per product, a shared DESIGN.md, tokens, and layout and accessibility checks in a browser.

SkillExtended access51Repository stars

A UI, presentation and graphics design skill for coding agents: canvas drafts driven through the superdesign CLI

SkillExtended access982Repository stars

A skill for interfaces without the generic AI look: typography, color, motion, component states and a critique of the result.

SkillMinimal access95Repository stars

A Codex skill: three distinct visual concepts, screenshot review and cutting excess, so interfaces look less templated.

SkillMinimal access137Repository stars

An interface design skill for the agent: diagnosis, four directions to choose, implementation and QA without an AI-template look

SkillExtended access685Repository stars

An MCP server and skill for interfaces: 31 design systems for shadcn/ui, UI and UX principles and accessibility review for agent-written code

MCP serverExtended access576Repository stars

Comparison with similar tools

Cards that share the main search query, and how they differ.

ToolOfficialAuthenticationRepository starsMain difference
Niblet (this card)nokey is optional87
Impeccableno108,873a skill with 23 commands and live browser iteration, without a screen catalogue
Frontend Design (Ilm-Alan)no167eight aesthetic anchors that fix palette and type rather than tie work to your product

README in short

The description explains the three steps: settle the contract, build from your system, check the rendered screen. Skill installation, two ways to connect the server, a table of five tools, the list of `niblet://` resources, `niblet-<command>` prompts and configuration variables follow.

README badge

Original SKILL.md

---
name: niblet
description: Keep interface work anchored to the product it belongs to instead of a generic template. Sets a short design contract, builds from the components and tokens already in the codebase, covers the states a surface can actually reach, and closes by looking at the rendered result. Use when building, reworking, or assessing a web or native interface. Trigger with "niblet", "niblet skill", "niblet designer ui", or "niblet review". Skip backend, CLI, data, and infrastructure work, prose-only tasks, and questions the product's own design system already settles.
license: Apache-2.0
metadata:
  version: '0.5.3'
  author: 'Mohamed Elkholy (elkaix)'
  organization: 'PyModel'
  source: 'https://github.com/PyModel/niblet-skill-mcp'
  compatibility: 'Claude Code, Codex, Cursor, and GitHub Copilot, or any agent that can open repository files and call an MCP tool.'
  tags: 'interface-design, product-ui, design-contract, state-coverage, accessibility, native'
---

# Niblet

Build an interface that belongs to this product, not a generic template. [Niblet](https://niblet.pymodel.com) is an optional reference catalogue; this skill also works entirely from local product evidence without an MCP connection, account, script, or browser automation.

## Start here

1. Identify the requested surface, action, and scope. Read the product brief, relevant current screens, components, tokens, content, and platform constraints. Inspect the repository directly; this skill has no setup script.
2. Select the surface mode below and write a compact design contract in the conversation or the existing surface brief. Ask only for a consequential decision that the available product evidence cannot answer. Mark other assumptions.
3. Read [the command playbook](references/commands.md) for the requested command. The local MCP adapter registers each entry as `niblet-<command>`; a standalone filesystem installation invokes the same work instructions in ordinary language. For native work, also read [native guidance](references/native.md).
4. Work within the contract. Use existing components and tokens before introducing new ones. If a concrete visual question remains unresolved, follow [the evidence policy](references/evidence.md); reference retrieval is optional, never a prerequisite to useful work.
5. Cover the applicable states and run the bounded finish gate. Report the delivered scope, evidence actually inspected, and any specific verification limitation.

**Routing:** with no target or command, present a short context-aware menu and wait for a choice rather than making changes. An explicit command loads its playbook entry. Otherwise treat the request as ordinary design work. For a new surface or replacement visual world without product context, run `init` first; narrow refinements can proceed from the incumbent implementation. `craft` aliases ordinary new work; `teach` aliases `init`.

**Authority order:** the user's current requirements and product brief; established product behavior, content, components, and design system; native platform and accessibility constraints; this skill; external references. Aesthetic preferences never overrule product truth, accessibility, or functional requirements.

## Four modes

Choose by the job of each surface, not the repository's category. Different surfaces in one product may use different modes. Persist the choice only in that surface's brief when persistence is requested; do not impose a project-wide mode.

| Mode           | User's job                  | Design priority                                                            | Common surfaces                              |
| -------------- | --------------------------- | -------------------------------------------------------------------------- | -------------------------------------------- |
| **Persuade**   | Decide and act              | Make the proposition, evidence, trade-offs, and next action understandable | Marketing, pricing, acquisition              |
| **Operate**    | Complete a task             | Legible state, efficient controls, predictable navigation, and recovery    | Apps, dashboards, settings, native utilities |
| **Read**       | Understand                  | Comprehension, typography, reading rhythm, navigation, and useful examples | Documentation, articles, guides              |
| **Experience** | Engage with the work itself | Let the artifact lead; keep navigation and chrome subordinate but usable   | Portfolios, galleries, interactive work      |

Mode is a prioritization tool, not a visual preset. A pricing page still needs usable controls; a gallery still needs accessible navigation; an application can have character without obscuring its tasks.

## Design contract

Keep this short enough to guide implementation. Record:

Report a problem