Skip to main content
plugin CX Codex

stark — Claude Code plugin for interface design and installation

stark guides an AI coding agent through interface decisions before implementation, then checks the rendered result. Use it to shape a new flow or review an existing screen.

Apache-2.0 ★ 1,596 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add hashgraph-online/awesome-codex-plugins
/plugin install stark@awesome-codex-plugins
Open on GitHub

What stark does

The plugin helps an agent identify the product surface, map user flows, and account for interface states before code is generated. It selects a small set of relevant references, creates a concise decision brief, and directs implementation toward the repository’s existing stack. The agent then inspects the rendered interface and revisits the most consequential issue. stark is a prompt-and-reference plugin, not a component library.

The package includes platform- and task-focused skills, reference material, explicit modes in commands/, and tools for platform detection and token export. Export targets include css, tailwind, swiftui, compose, and winui. Generated applications do not need a runtime dependency from stark; they continue to use the project’s existing frontend or native stack.

What it helps with

  • map a user flow before generating interface code
  • apply platform conventions to a web or native screen
  • plan interface states, responsive behavior, and motion
  • audit a rendered page and rank fixes by impact
  • export design tokens to a supported target

Example prompts for the agent

  • Use stark to redesign the incident dashboard around triage and realistic interface states.
  • Ask stark to plan a SwiftUI onboarding flow that follows native conventions.
  • Use stark to audit this landing page for accessibility, responsive behavior, and visual evidence.

How to install stark

Plugin marketplace

/plugin marketplace add hashgraph-online/awesome-codex-plugins
/plugin install stark@awesome-codex-plugins

Step by step, with commands for each platform: Claude Code plugins: marketplaces, installing, and building your own

Questions about stark

How do I install stark in Claude Code?

Add the marketplace source with /plugin marketplace add hashgraph-online/awesome-codex-plugins, then install it with /plugin install stark@awesome-codex-plugins.

What does the stark plugin do?

It guides an agent through product flow, platform-specific interface choices, and implementation planning, then helps inspect the rendered result and prioritize fixes.

Does stark add a dependency to generated applications?

No. stark provides prompts and references rather than UI components, and generated applications do not need its runtime dependency. They use the project’s existing stack.

Source text

stark · Apache-2.0
<p align="center">
  <img src="assets/logo/stark-mark.svg" alt="Stark logo" width="96" height="96">
</p>

# Stark

[![CI](https://github.com/f0d010c/stark/actions/workflows/ci.yml/badge.svg)](https://github.com/f0d010c/stark/actions/workflows/ci.yml)
[![Release](https://img.shields.io/github/v/release/f0d010c/stark)](https://github.com/f0d010c/stark/releases)
[![License](https://img.shields.io/badge/license-Apache--2.0-8b5cf6)](LICENSE)

Design direction for AI coding agents—grounded in product behavior, platform idiom, and rendered evidence.

Stark routes UI work across web, Windows, Apple, Android, cross-platform, UX, and design tokens. It makes the agent choose the product object, user flow, visual language, states, responsive behavior, motion ownership, and proof strategy before generating code.

## Why Stark

Most weak generated interfaces fail before the first CSS rule: they choose a generic structure, decorate it, and call the result polished. Stark changes that sequence.

1. Route the request to the correct platform and surface.
2. Load a small, relevant reference bundle.
3. Write a compact decision brief.
4. Build in the repository's existing stack.
5. Inspect rendered evidence.
6. Repair the highest-impact failure and re-check it.

The runtime uses two core references and at most two conditional references per task. The full library remains available as a catalog without flooding the agent's context.

## Install

### Codex

Install this repository as a plugin, then invoke Stark naturally:

```text
Use Stark to redesign this dashboard around incident triage.
```

The Codex manifest is at `.codex-plugin/plugin.json`.

### Claude Code

Add the repository as a plugin marketplace source:

```text
/plugin marketplace add f0d010c/stark
/plugin install stark@stark
```

The compatibility manifest is at `.claude-plugin/plugin.json`.

## Examples

```text
Use Stark to design a React analytics dashboard for returning operators.
Prioritize scan speed, realistic states, keyboard use, and mobile replacement.
```

```text
Use Stark to redesign this SwiftUI onboarding flow.
Preserve native conventions and prove recovery from denied permissions.
```

```text
Use Stark to audit this landing page for generic structure, weak proof,
typography, accessibility, responsive behavior, and unnecessary libraries.
```

## Capabilities

| Area | What Stark decides |
|---|---|
| UX | Flows, information architecture, first value, states, recovery, repeated-use ergonomics |
| Web | Surface type, stack, composition, typography, copy, assets, responsive behavior, motion |
| Native | Windows, Apple, and Android idioms, controls, navigation, density, materials, accessibility |
| Cross-platform | Shared versus platform-owned behavior for Electron, Tauri, React Native, Flutter, and CMP |
| Design systems | Tokens, component APIs, variants, state galleries, themes, density, drift checks |
| Audit and QA | Usability, accessibility, visual quality, runtime behavior, repair priority, re-check evidence |
| Motion | Choreography, ownership, fallbacks, reduced motion, performance budgets, acceptance frames |

## Included tools

- Platform detector: `python scripts/detect_platform.py --text "Build a WinUI settings app"`
- Token exporter: `python scripts/token_export.py --input assets/tokens/fluent-2.json --target winui --output Resources.xaml`
- Deterministic plugin archive: `npm run pack:plugin`
- Repository checks: `npm run check`

Token export targets are `css`, `tailwind`, `swiftui`, `compose`, and `winui`.

## Repository map

```text
SKILL.md                 Main router and context budget
skills/                  Platform and task-specific skills
references/              Narrow decision and implementation references
commands/                Explicit Stark modes
assets/                  Tokens, fonts, logo, and curated proof
scripts/                 Detector, token exporter, packaging, validation
evals/                   Trigger and design-quality evaluation cases
tests/                   Behavioral and repository-health tests
```

## Development

Requires Python 3.12+ and Node.js 20+.

```bash
npm ci
npm run check
npm run pack:plugin
```

`npm run check` runs unit tests, strict marketplace lint, smoke prompts, local-link checks, context-budget checks, secret hygiene, line-ending checks, and archive validation.

See [CONTRIBUTING.md](CONTRIBUTING.md), [reference governance](docs/reference-governance.md), and the [review contract](docs/review-contract.md).

## Scope

Stark is a prompt-and-reference plugin, not a component library. It works with the user's existing frontend or native stack and does not require a runtime dependency in generated applications.

The project can be distributed through npm in the future, but the current package is intentionally marked private while an install/doctor CLI and npm-specific user value are designed. The plugin archive remains the canonical artifact.

## License

Apache-2.0. See [LICENSE](LICENSE) and [NOTICE](NOTICE).

© stark contributors · Apache-2.0 · hashgraph-online/awesome-codex-plugins

Similar plugins

All plugins for Design →

From the same set391

The whole set →

Project sponsors

Companies that keep this analytics open