Implement a complete UI screen or feature from a Form visual spec.

MITAuto-check: notesFrontend & Design

Install Prism UI

skills CLI
$ npx skills add jeremylongshore/tons-of-skills-marketplace --skill prism-ui -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install jeremylongshore/tons-of-skills-marketplace prism-ui --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/jeremylongshore/tons-of-skills-marketplace.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/ai-agency/tonone/skills/prism-ui .claude/skills/prism-ui && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
prism-ui
GitHub stars
2.8k
Token cost
~2.6k tokens
SKILL.md length
812 words
Files
2
Skills in repo
3,342
Repo updated
First seen
Licence
MIT

At a glance

Implement a complete UI screen or feature from a Form visual spec.

  • Works in 5 steps: Read the Environment → Read the Spec → Plan the Component Structure → …
  • Asked to build a page
  • SKILL.md covers Steps and Delivery
  • Calls python3

What it does

Prism UI is an agent skill from jeremylongshore/tons-of-skills-marketplace. Implement a complete UI screen or feature from a Form visual spec. Use when asked to "build a page", "implement this screen", "build the frontend for this feature", or "create this UI".

Its SKILL.md is about 2.6k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files (for example `.claude-plugin/plugin.json`).

It sits in Frontend & Design. It works with TypeScript. The repository describes itself as: Model-agnostic agent-skills platform with a harness-free canonical layer, verified adapters, and the ccpi package manager. Explore at tonsofskills.com. The licence is MIT.

When your agent uses it

  • Asked to build a page
  • Implement this screen
  • Build the frontend for this feature

Example prompts

  • “build a page”
  • “implement this screen”
  • “build the frontend for this feature”
  • “/prism-ui”

Requirements

  • Python 3
  • Pre-approved tools (allowed-tools): Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch, Task, TodoWrite, AskUserQuestion

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Read the Environment
  2. Read the Spec
  3. Plan the Component Structure
  4. Write the Implementation
  5. Summarize

What it can do on your machine

Read from SKILL.md and the folder at commit cfae287. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Write
    • Edit
    • Bash
    • Glob
    • Grep
    • WebFetch
    • WebSearch
    • Task
    • TodoWrite

    …and 1 more on the same allowed-tools line.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • python3

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Prism UI loads about 2.6k tokens when it runs. Until then it costs about 49 tokens; SKILL.md has 812 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~49
When it runs · the whole SKILL.md, loaded when a task matches
~2.6k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch, Task, TodoWrite, AskUserQuestion

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from jeremylongshore/tons-of-skills-marketplace at commit cfae287, republished under its MIT licence (© jeremylongshore). 812 words, ~2,587 tokens.

Download SKILL.mdSave it as .claude/skills/prism-ui/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
prism-ui
description
Implement a complete UI screen or feature from a Form visual spec. Use when asked to "build a page", "implement this screen", "build the frontend for this feature", or "create this UI".
allowed-tools
Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch, Task, TodoWrite, AskUserQuestion
version
0.6.4
author
tonone-ai <hello@tonone.ai>
license
MIT

Implement a UI Screen or Feature

You are Prism — the frontend and developer experience engineer from the Engineering Team. Given a Form visual spec (or a description of what to build), you write the implementation — complete, responsive, accessible, wired to real data. Not a wireframe, not a scaffold, the actual code.

Follow the output format defined in docs/output-kit.md — 40-line CLI max, box-drawing skeleton, unified severity indicators, compressed prose.

Steps

Step 0: Read the Environment

Before writing anything:

  1. Check package.json — framework, styling, state management, existing component libraries
  2. Check for design tokens: tailwind.config.*, CSS custom property files, Form's token output
  3. Check for TypeScript: tsconfig.json
  4. Scan existing pages/screens: src/app/, src/pages/, app/, pages/ — understand routing conventions, layout wrappers, and component patterns in use
  5. Check for API layer: existing fetch utilities, API routes, tRPC setup, GraphQL schema, server actions
  6. Check for existing shared components: src/components/, ui/ — reuse what exists before writing new

If no frontend exists and there's no spec for the stack, default to: Next.js App Router + TypeScript + Tailwind CSS + Radix UI primitives.

Stop if design tokens are missing. Ask Form for the token file. Do not invent visual values.

Step 1: Read the Spec

Form's visual spec is the contract. Before writing a line, extract:

  • Layout — page structure, grid, spacing system in use
  • Components — which components appear; check if they already exist in the codebase
  • Typography — which scale steps map to which roles (heading, label, body, caption)
  • Color usage — which semantic tokens apply to which surfaces
  • States — what does loading look like? Error? Empty? The spec may not cover all of these; implement the gaps using the token system and flag what you assumed
  • Responsive behavior — how does the layout change at mobile/tablet/desktop? If unspecified, implement sensible defaults and flag

One question to Form if there's a genuine blocker. Don't request a full review session — implement with reasonable assumptions and flag them in the summary.

Step 2: Plan the Component Structure

Before writing the page, map the component tree:

  • Identify reusable components vs. page-specific layout
  • Reuse existing shared components where they fit — don't duplicate
  • Break the page into components with clear, single responsibilities
  • Define TypeScript types for all data structures upfront — no any
  • Decide server vs. client boundary: default to Server Components; mark 'use client' only where interactivity requires it (event handlers, browser APIs, stateful hooks)
// Example: UserProfilePage
UserProfilePage (server — fetches data)
├── ProfileHeader (server — static layout)
│   ├── Avatar (shared component)
│   └── UserMeta (server)
├── ActivityFeed (client — real-time updates)
│   ├── FeedItem (server-renderable)
│   └── LoadMoreButton (client)
└── SettingsPanel (client — form interactions)
    ├── FormField (shared component)
    └── SaveButton (shared component)
Design Intelligence (via uiux)

After planning the component structure (Step 2), query performance and stack guidelines:

bash
python3 -m prism_agent.uiux search --domain react --query "{optimization_area}" --limit 3

Use results to:

  • Apply framework-specific performance patterns (memoization, code splitting, Suspense)
  • Avoid documented performance anti-patterns
  • Choose correct data fetching strategy based on the guidelines
Show full SKILL.md (383 more words)Show less
Step 3: Write the Implementation

Write all files. Not scaffolding — complete, working code.

Page / route file:

  • Wire up data fetching using the framework's pattern (Server Components + fetch, getServerSideProps, load, loaders)
  • Pass typed data down to components — no prop drilling beyond 2 levels; use composition or context
  • Handle auth/authorization if the page requires it (check existing auth setup)

Data fetching:

  • Server-side by default — render with real data, not client-side spinners for initial load
  • Loading state: skeleton screens that match the page layout, not a centered spinner replacing everything
  • Error state: user-friendly message + retry action; not a raw error dump or blank page
  • Empty state: helpful message that explains why there's nothing and what to do; not silence
  • Pagination / infinite scroll if the dataset requires it

Responsive layout:

  • Mobile-first: start at 375px, layer up with sm:, md:, lg: breakpoints
  • No horizontal overflow at any breakpoint
  • Touch targets minimum 44×44px on mobile
  • Navigation patterns that work on both mobile (drawer/bottom nav) and desktop (sidebar/top nav)

Accessibility:

  • Semantic HTML throughout — <main>, <nav>, <header>, <section>, <article>, <aside>
  • Landmark regions so screen reader users can navigate
  • Heading hierarchy: one <h1> per page, logical <h2>/<h3> nesting
  • All interactive elements keyboard-reachable; tab order matches visual order
  • Focus management on route transitions and modal/drawer open/close
  • aria-live regions for content that updates without navigation
  • Images: alt text that describes function, not appearance; alt="" for decorative images
  • Forms: <label> elements associated with inputs; error messages linked via aria-describedby

Token discipline:

  • All visual values from Form's tokens — no hardcoded hex, raw px spacing, or ad hoc font sizes
  • If a value isn't in the tokens, flag it and ask Form; don't invent

State management:

  • URL state for filters, sort, pagination — keeps the page bookmarkable and shareable
  • Local component state for ephemeral UI (open/closed, hover, focus)
  • Server state via React Query / TanStack Query / SWR for client-fetched data with caching
  • Form state via React Hook Form or native form actions; preserve state on validation errors

Example — settings page (Next.js App Router + Tailwind):

tsx
// app/settings/page.tsx — Server Component
import { getSession } from "@/lib/auth";
import { getUserSettings } from "@/lib/api/user";
import { SettingsForm } from "./SettingsForm";
import { redirect } from "next/navigation";

export default async function SettingsPage() {
  const session = await getSession();
  if (!session) redirect("/login");

  const settings = await getUserSettings(session.userId);

  return (
    <main className="mx-auto max-w-2xl px-4 py-10">
      <h1 className="text-[--text-heading] text-2xl font-semibold mb-8">
        Account settings
      </h1>
      <SettingsForm initialValues={settings} userId={session.userId} />
    </main>
  );
}
tsx
// app/settings/SettingsForm.tsx — Client Component (needs interactivity)
"use client";

import { useActionState } from "react";
import { updateSettings } from "@/lib/actions/user";
import { FormField } from "@/components/ui/FormField";
import { Button } from "@/components/ui/Button";
import type { UserSettings } from "@/lib/types";

type Props = { initialValues: UserSettings; userId: string };

export function SettingsForm({ initialValues, userId }: Props) {
  const [state, action, isPending] = useActionState(updateSettings, null);

  return (
    <form action={action} className="space-y-6">
      <input type="hidden" name="userId" value={userId} />

      <FormField
        label="Display name"
        name="displayName"
        defaultValue={initialValues.displayName}
        error={state?.errors?.displayName}
        required
      />

      <FormField
        label="Email"
        name="email"
        type="email"
        defaultValue={initialValues.email}
        error={state?.errors?.email}
        required
      />

      {state?.error && (
        <p role="alert" className="text-sm text-[--color-danger]">
          {state.error}
        </p>
      )}

      {state?.success && (
        <p role="status" className="text-sm text-[--color-success]">
          Settings saved.
        </p>
      )}

      <Button type="submit" loading={isPending}>
        Save changes
      </Button>
    </form>
  );
}

Write all files the feature needs. Don't stop at the page file.

Step 4: Summarize
┌─ UI: [Screen/Feature Name] ─────────────────────────────────┐
│ Route: [path]                                                 │
│ Stack: [framework · styling · state · data fetching]          │
│                                                               │
│ Files written                                                 │
│   [list each file and its role]                              │
│                                                               │
│ Component tree                                                │
│   [indented tree — server/client boundary marked]            │
│                                                               │
│ Data                                                          │
│   Source: [API endpoints / server actions / DB]              │
│   Loading: [skeleton approach]                               │
│   Error: [user-facing error approach]                        │
│   Empty: [empty state approach]                              │
│                                                               │
│ Responsive: mobile (375px) · tablet (768px) · desktop        │
│                                                               │
│ a11y: [landmark regions, heading hierarchy, keyboard model]  │
│                                                               │
│ Spec gaps filled: [any assumptions made — flag for Form]     │
└──────────────────────────────────────────────────────────────┘

Delivery

If output exceeds the 40-line CLI budget, invoke /atlas-report with the full findings. The HTML report is the output. CLI is the receipt — box header, one-line verdict, top 3 findings, and the report path. Never dump analysis to CLI.

© jeremylongshore, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file in plugins/ai-agency/tonone/skills/prism-ui of jeremylongshore/tons-of-skills-marketplace.

  • SKILL.md
  • .claude-plugin/plugin.json

Open the folder on GitHubat commit cfae287

Compare with similar skills

Prism UI next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Prism UI compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Prism UI this skilljeremylongshore/tons-of-skills-marketplace2.8k—~2.6kAutomated safety check: NotesMIT
Web Artifacts Builderanthropics/skills180k40 repos~769Automated safety check: PassApache-2.0
Ink Tui Wizardnovuhq/novu40k—~1.9kAutomated safety check: PassMIT
Frontend Module Standardssiteboon/claudecodeui14k—~2.6kAutomated safety check: PassAGPL-3.0
Dify Component Writing Guidelanggenius/dify158k—~626Automated safety check: PassCustom licence
React Frontend Development Guidelinesdiet103/claude-code-infrastructure-showcase10k2 repos~2.9kAutomated safety check: PassMIT

Similar skills

  • Web Artifacts Builder

    anthropics/skills

    Official

    Builds multi-component claude.ai HTML artifacts as a small React, TypeScript and Tailwind project, then bundles it into one shareable HTML file.

    180k GitHub starsUsed in 40 repos~769 tokens
    Frontend & DesignAuto-check passed
  • Ink Tui Wizard

    novuhq/novu

    Build terminal user interfaces (TUIs) using Ink (React for CLIs) and @inkjs/ui with a reactive, session-driven wizard pattern.

    40k GitHub stars~1.9k tokensUpdated yesterday
    Frontend & DesignAuto-check passed
  • Frontend Module Standards

    siteboon/claudecodeui

    Enforces one repository's React and TypeScript module layout for code under src/: source-root imports, feature barrels, deliberate exports and no deep imports.

    14k GitHub stars~2.6k tokensUpdated 2 days ago
    Frontend & DesignAuto-check passed
  • Use when implementing or refactoring React/TypeScript components and the task requires decisions about component ownership, feature boundaries, state, data…

    158k GitHub stars~626 tokensUpdated today
    Frontend & DesignAuto-check passed
  • React Frontend Development Guidelines

    diet103/claude-code-infrastructure-showcase

    Guidelines for React 18 and TypeScript apps covering Suspense data fetching, lazy loading, feature folders, MUI v7 styling, TanStack Router and performance.

    10k GitHub starsUsed in 2 repos~2.9k tokens
    Frontend & DesignAuto-check passed
  • Formik Form Patterns

    ChrisWiles/claude-code-showcase

    Shows how to build forms with Formik and Yup validation, including conditional rules, field helpers, GraphQL submission, edit forms and multi-step flows.

    6.1k GitHub starsUsed in 3 repos~2.1k tokens
    Frontend & DesignAuto-check passed

More from jeremylongshore/tons-of-skills-marketplace

All 3,342 skills in this repo
  • Performing Security Code Review

    jeremylongshore/tons-of-skills-marketplace

    Execute this skill enables AI assistant to conduct a security-focused code review using the security-agent plugin.

    2.8k GitHub starsUsed in 2 repos~1.3k tokens
    Auto-check: notes
  • Adapting Transfer Learning Models

    jeremylongshore/tons-of-skills-marketplace

    Build this skill automates the adaptation of pre-trained machine learning models using transfer learning techniques.

    2.8k GitHub stars~1.1k tokensUpdated today
    Auto-check passed
  • Agent Context Loader

    jeremylongshore/tons-of-skills-marketplace

    Execute proactive auto-loading: automatically detects and loads agents.md files.

    2.8k GitHub stars~1.1k tokensUpdated today
    Auto-check passed
  • Aggregating Performance Metrics

    jeremylongshore/tons-of-skills-marketplace

    Aggregate and centralize performance metrics from applications, systems, databases, caches, and services.

    2.8k GitHub stars~1.2k tokensUpdated today
    Auto-check passed
  • Analyzing Capacity Planning

    jeremylongshore/tons-of-skills-marketplace

    Execute this skill enables AI assistant to analyze capacity requirements and plan for future growth.

    2.8k GitHub stars~947 tokensUpdated today
    Auto-check passed
  • Analyzing Database Indexes

    jeremylongshore/tons-of-skills-marketplace

    Process use when you need to work with database indexing. An agent skill from jeremylongshore/tons-of-skills-marketplace.

    2.8k GitHub stars~2k tokensUpdated today
    Auto-check passed

Works with

Questions about Prism UI

What does Prism UI do?

Implement a complete UI screen or feature from a Form visual spec. Prism UI is an agent skill from jeremylongshore/tons-of-skills-marketplace. Implement a complete UI screen or feature from a Form visual spec.

When should I use Prism UI?

Prism UI fits situations like: asked to build a page; implement this screen; build the frontend for this feature.

How do I install Prism UI in Claude Code?

Run `npx skills add jeremylongshore/tons-of-skills-marketplace --skill prism-ui -a claude-code`. Or copy the skill folder (plugins/ai-agency/tonone/skills/prism-ui in jeremylongshore/tons-of-skills-marketplace) into .claude/skills/prism-ui in your project. Claude Code loads it when a task matches its description.

How do I install Prism UI in Codex?

Run `npx skills add jeremylongshore/tons-of-skills-marketplace --skill prism-ui -a codex`. Or copy the skill folder (plugins/ai-agency/tonone/skills/prism-ui in jeremylongshore/tons-of-skills-marketplace) into .agents/skills/prism-ui in your project. Codex loads it when a task matches its description.

Can I use Prism UI in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add jeremylongshore/tons-of-skills-marketplace --skill prism-ui -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/prism-ui, .gemini/skills/prism-ui, .github/skills/prism-ui and .opencode/skills/prism-ui in your project.

What does Prism UI need to run?

Going by SKILL.md and its folder, Prism UI needs the command-line tools its instructions call (python3). Our summary lists: Python 3. Its frontmatter pre-approves these tools: Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch, Task, TodoWrite, AskUserQuestion.

Does Prism UI access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Prism UI safe to install?

Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Prism UI use?

Prism UI is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Prism UI use?

About 2.6k tokens (SKILL.md is roughly 10k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Prism UI?

Skills that share tags, products or a category with Prism UI: Web Artifacts Builder (anthropics/skills, 180k stars), Ink Tui Wizard (novuhq/novu, 40k stars), Frontend Module Standards (siteboon/claudecodeui, 14k stars) and Dify Component Writing Guide (langgenius/dify, 158k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Prism UI?

jeremylongshore (a GitHub user) maintains it in jeremylongshore/tons-of-skills-marketplace, which has 2,827 GitHub stars. The repository holds 3,342 skills in this directory. The repository was last updated on October 10, 2026.

Source: jeremylongshore/tons-of-skills-marketplace on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.