Empty States logo

Empty States

Organization
KyaniteLabs
empty-states

Empty, loading, and error-state design. Use for first-run screens, zero results, empty lists/tables/dashboards, loading skeletons, offline/permission errors, retries, layout stability, and state copy.

Overview

PublisherKyaniteLabs
Repositorytastecheck
Skill nameempty-states
Stars
10
Forks
7
Bundled files
3
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 3 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by KyaniteLabs on GitHub. Read the source before you install it.

Installation

Install the Empty States AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/KyaniteLabs/tastecheck/tree/main/skills/empty-states
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/KyaniteLabs/tastecheck.git /tmp/tastecheck
mkdir -p .claude/skills
cp -r /tmp/tastecheck/skills/empty-states .claude/skills/empty-states
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Empty States in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Empty States on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Empty States is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Empty States

Every reachable data state needs truthful treatment; absence and failure need different next moves.

Start with a state contract, not a set of illustrations

Name region and transition before copy/illustration. Record:

QuestionDecision to record
User goalWhat they came to find, create, compare, or finish in this region
Data authorityNetwork source, local draft, cached result, permission boundary, or user-entered filter
Entry conditionThe observable event that enters loading, zero-result, error, stale, or partial state
ContinuityWhat remains visible and editable while the state is active
RecoveryThe action that can change the state, its owner, and whether retry is safe to repeat
Exit proofThe event that replaces the state and the announcement/visual confirmation the user receives

First-use, zero results, and permission absence need different truth. Trusted cached data is stale content with progress, not a blank reset.

Model the reachable state set

Design loading when work can be in flight, empty when success can contain zero items, and error when the region can fail. Static/local regions need not invent states. Add stale, partial, awaiting-input, or pending-mutation only when their entry condition exists; never merge zero, unavailable, and loading.

Loading: communicate the wait honestly

Use a layout-matching skeleton when final geometry is known and it aids orientation. Use determinate progress when measurable, compact status for short waits, and a spinner only as a supporting cue. Delay transient indicators when measured latency makes flashing likely, but keep slow work visible. Never imply unknowable progress/shape. Use optimistic UI only when rollback and reconciliation are safe.

Empty: the three flavors, each with a next step

Every empty state has heading, context, and safe next action. First-run teaches; user-cleared affirms completion; no-results names query/filter and offers clear/broaden/correct/create. If no action exists, say what will fill it.

Error: explain, reassure, offer recovery

Use plain, blameless language; distinguish offline, permission, not-found, and server when recovery differs. Preserve work; offer retry, a working route, or support proportionate to the consequence.

Preserve continuity through transitions

Retain position, content, filters, and drafts unless safety/integrity forbids it. Make retry visible without duplicate mutation; explain rollback and return focus to repair. Record idempotent, confirmation-required, or support-only retry—never promise retry can resolve permission or duplicate-money risk. Give each request an owner; late responses must not replace current state.

Quick start

Use references/patterns.md for state markup/copy. Render one explicit state per region, reserve space, announce changes, and preserve work across errors.

Reference files

  • references/patterns.md — patterns, copy, skeletons, announcements.
  • references/decision-records.md — novel-case ADR rules.

Decision order and evidence

For each state, record cause, retained context, next action, retry semantics, exit proof, and accessible recovery; n/a requires subject absence. Hand control behavior to component-states.

Self-check

  1. Reachable loading, empty, and error states are distinct and truthful?
  2. Empty has heading/context/forward action; no-results has an exit?
  3. Errors explain/recover without raw internals; loading matches what is known?
  4. Changes announce, preserve work, reject stale responses, and state safe retry/cached/partial behavior?

Deliver

Deliver a region matrix: entry, message, retained context, recovery, exit, announcement, and layout-shift evidence. Keep containers stable; hand adjacent scope off.

Contract (generated)

Canonical detail: contract.json.

  • Route: A data region needs first-use, no-results, loading, permission, or error states.; avoid: The issue is only a button or field state.
  • Exclude: Do not use a spinner as the only loading communication. (+1 in contract.json)
  • Stop / handoff: Stop when the cause of absence cannot be distinguished. (+1 in contract.json); receives [component-states, data-viz, design-system-interview, deslop-ui, improve-existing-website, tasteroll] -> sends [component-states, a11y-pass, humanize-copy, tastecheck-pass, cognitive-a11y]
  • Output: domain-specific data-region state plan
  • Evidence: table_with_evidence with status, reason, remediation, evidence, provenance.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Empty States AI skill do?

Empty, loading, and error-state design. Use for first-run screens, zero results, empty lists/tables/dashboards, loading skeletons, offline/permission errors, retries, layout stability, and state copy.

Why use Empty States on TypingMind?

Because you install it once and use it with any model. Empty States is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Empty States in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/KyaniteLabs/tastecheck/tree/main/skills/empty-states. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Empty States?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Empty States?

As many as you like. As long as a model supports skills, you can use Empty States with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Empty States AI skill free?

Yes. It is published on GitHub by KyaniteLabs under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇