Standardizes Prowler UI development using shadcn/ui and Tailwind.

Install

mkdir -p .claude/skills/prowler-ui && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/7823" && unzip -o skill.zip -d .claude/skills/prowler-ui && rm skill.zip

Installs to .claude/skills/prowler-ui

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Prowler UI-specific patterns. For generic patterns, see: typescript, react-19, nextjs-15, tailwind-4. Trigger: When working inside ui/ on Prowler-specific conventions (shadcn vs HeroUI legacy, folder placement, actions/adapters, shared types/hooks/lib).
253 chars · catalog description✓ has a “when” triggerlonger than Claude Code's old 250-char listing cap (fine on current versions)
Intermediate

Key capabilities

  • →Generate shadcn/ui components
  • →Configure Tailwind styling via cn()
  • →Implement server actions in specific folders
  • →Manage client/server component separation
  • →Apply zustand state management patterns

How it works

It enforces a component placement and technology standard, favoring shadcn/ui over legacy HeroUI while organizing logic into actions, adapters, and local components.

Inputs & outputs

You give it
UI component requirements
You get back
Formatted React/Tailwind code

When to use prowler-ui

  • →Build new features using shadcn/ui
  • →Structure UI actions and data adapters
  • →Apply Tailwind styling conventions
  • →Migrate or maintain legacy UI components

About this skill

Related Generic Skills

  • typescript - Const types, flat interfaces
  • react-19 - No useMemo/useCallback, compiler
  • no-use-effect - Derive state, handlers, server data; no direct useEffect
  • prowler-ui-browser-review - Browser sign-off for user-visible changes
  • nextjs-16 - App Router, Server Actions
  • tailwind-4 - cn() utility, styling rules
  • zod-4 - Schema validation
  • zustand-5 - State management
  • ai-sdk-5 - Chat/AI features (installed: AI SDK 6, @ai-sdk/react 3)
  • vitest - Unit (jsdom) and browser integration tests
  • playwright - E2E testing (see also prowler-test-ui)

Tech Stack (Versions)

Source of truth is ui/package.json (pinned exact versions). At 5.48:

Next.js 16.4 | React 19.2 (React Compiler on) | Tailwind 4.1 | shadcn/ui + Radix
Zod 4.4 | React Hook Form 7.62 | Zustand 5.0 | NextAuth 5.0.0-beta.32 | Recharts 2.15
AI SDK 6 (`ai`) + @ai-sdk/react 3 | LangChain/LangGraph (@langchain/*) for Lighthouse
Vitest 4.1 | Playwright 1.56 | TypeScript 5.5 | pnpm 11 | Node >= 22.13

CRITICAL: Component Library Rule

  • ALWAYS: Use shadcn/ui + Tailwind (components/shadcn/)
  • NEVER: Add components to components/ui/ (temporary re-export shims for the prowler-cloud overlay only)

Design System Discipline (REQUIRED)

Applies to ALL UI work. The design system is the single source of truth — reuse it exactly, extend it deliberately.

  • Reuse first, never reinvent. Before building anything, search components/shadcn/ and existing usages in the codebase for an equivalent. Do NOT create a custom component, modal wrapper, or primitive when one already exists.
  • Use exactly the defined variants/styles — no more, no less. At the call site, drive appearance through the component's variant/size/tone props. Never add ad-hoc visual className (color, opacity, hover/focus/disabled, spacing-for-looks) to shared controls (Button, SelectTrigger, SelectItem, Modal, badges…), and never skip the correct semantic variant.
  • Modals: only @/components/shadcn/modal. Selects: components/shadcn/select.
  • Colors: reuse existing semantic tokens from ui/styles/globals.css. No raw Tailwind color utilities (e.g. bg-blue-950/40), no hex. If no token fits, STOP and ask the design owner — do not invent or near-duplicate tokens.
  • Need a genuinely new variant/token? That is a design-system change: add it to the shared component API (with design sign-off), then consume it. It is never a call-site decision.
  • Design-system-shaped patterns (callouts, hints, empty states) go into components/shadcn/ as compound components, even with one consumer. When a shadcn primitive carries stock tokens that globals.css does not define (e.g. bg-popover), fix the primitive with house tokens instead of patching call sites.
  • Shared components serve many screens. Before changing one for a request about a single screen, grep its usages and check every render context. Nested finding rows have no header row and rely on per-cell labels; put the change at the call site.

Lint rejects raw palette classes, hex values, var() in className and imports from components/ui/. When reviewing UI PRs, also flag custom modals/primitives that duplicate shadcn, call-site visual className on shared controls, and new variants/tokens introduced without going through the shared component API.

DECISION TREES

Code Location

New features live with their route (reference: app/(prowler)/alerts/). Older features still live in the global folders; follow their layout unless the task is the migration.

Server action + adapter → app/(prowler)/<domain>/_actions/ (index.ts barrel)
Feature component       → app/(prowler)/<domain>/_components/<sub>/ (index.ts per subfolder)
Pure helpers, schemas   → app/(prowler)/<domain>/_lib/
Feature types           → app/(prowler)/<domain>/_types/ (index.ts barrel)
Used by 2+ domains      → components/shared/, lib/, types/, hooks/
UI primitive            → components/shadcn/
API route handler       → app/api/...
Needs state/handlers    → "use client"; otherwise a Server Component (no directive)

Import across _ folders with @/app/(prowler)/<domain>/_lib/...; use relative paths inside one folder.

Deprecated: components/ui/ is a temporary re-export shim that maps legacy import paths to components/shadcn/ for the prowler-cloud overlay. HeroUI is fully removed. Never add or import components here — use @/components/shadcn (primitives) or @/components/{domain} instead. Delete the shim once the cloud repo migrates to @/components/shadcn.

Styling Decision

Tailwind class exists? → className
Dynamic value?         → style prop
Conditional styles?    → cn()
Static only?           → className (no cn())
Recharts/library?      → CHART_COLORS constant + var()

Scope Rule (ABSOLUTE)

  • Used 2+ domains → components/shared/, lib/, types/ or hooks/
  • Used by 1 feature → keep it in that feature's app/(prowler)/<domain>/_* folders
  • Exception: design-system-shaped patterns go to components/shadcn/ even with one consumer

Project Structure

ui/
├── app/
│   ├── (auth)/              # Sign-in, sign-up, invitation
│   ├── (prowler)/           # Main app; each route owns _actions/_components/_lib/_types
│   └── api/                 # Route handlers (proxies, auth, health)
├── components/
│   ├── shadcn/              # shadcn/ui primitives and design-system patterns (USE THIS)
│   ├── shared/              # Cross-domain composed components (2+ domains)
│   ├── ui/                  # DEPRECATED shim → re-exports shadcn for the Cloud overlay
│   ├── {domain}/            # Older domain components (findings, providers, scans...)
│   ├── filters/ graphs/ icons/
├── actions/                 # Older server actions ({feature}/{feature}.ts + .adapter.ts)
├── types/ hooks/ lib/       # Shared code (cn() in lib/utils.ts, isCloud() in lib/shared/env.ts)
├── store/                   # Zustand stores shared across routes
├── __tests__/               # Vitest shared harness (render-browser, MSW handlers)
├── tests/                   # Playwright E2E
├── changelog.d/             # Towncrier fragments (see prowler-changelog)
├── eslint-suppressions.json # Frozen lint violations (never add entries)
├── proxy.ts                 # Next 16 proxy (auth + security headers)
└── styles/globals.css       # Tailwind 4 config, design tokens, container-query breakpoints

Feature Guides

Complex features keep their own AGENTS.md next to the code:

  • app/(prowler)/lighthouse/AGENTS.md: Lighthouse v1 vs v2 owner map and the chat stream contract
  • app/(prowler)/realtime/AGENTS.md: Prowler Realtime (Cloud only)

Server and Client Boundary

  • Server Components fetch; client components receive data or a promise unwrapped with use().
  • Never pass a function across the boundary. components/filters/data-filters.ts stays plain data; labelFormatter and similar attach in a "use client" wrapper such as app/(prowler)/invitations/_components/invitations-filters.tsx. TypeScript and jsdom tests accept the bad version; only the real page throws.
  • Cloud-only UI is gated with isCloud() (lib/shared/env.ts). Paid gates are seams whose OSS body returns the self-hosted default (lib/s3-integration-access.ts, lib/report-download-access.ts, lib/findings-access.ts); the Cloud overlay replaces the body.

Layout

  • sm:…2xl: are redefined in styles/globals.css: container queries inside [data-responsive-container] (set on <main>, so the side panel's push re-evaluates them) and media queries elsewhere. Use min-[64rem]: when you need viewport semantics inside <main>.
  • <main> is a container, so it becomes the containing block of fixed descendants. Portal them to document.body (components/findings/floating-selection-actions.tsx).
  • Browser tests that check layout wrap the component in <div data-responsive-container className="@container" style={{ width }}>; otherwise the variants follow the test viewport.
  • No layout shift: decide visibility from synchronous signals (the runtime config island), render the structure on first paint, and size skeletons like the real content.

Recharts (Special Case)

For Recharts props that don't accept className:

Reuse shared color maps first (SEVERITY_COLORS, MUTED_COLOR in ui/types/severities.ts); otherwise a local constant of existing tokens (pattern in ui/components/graphs/donut-chart.tsx):

const CHART_COLORS = {
  emptyState: "var(--border-neutral-tertiary)",
};

// Only use var() for library props, NEVER in className
<Cell fill={SEVERITY_COLORS.critical} />
<CartesianGrid stroke={CHART_COLORS.emptyState} />

Form + Validation Pattern

"use client";
import { useForm } from "react-hook-form";
import { zodResolver } from "@hookform/resolvers/zod";
import { z } from "zod";

const schema = z.object({
  email: z.email(),  // Zod 4 syntax
  name: z.string().min(1),
});

type FormData = z.infer<typeof schema>;

export function MyForm() {
  const { register, handleSubmit, formState: { errors } } = useForm<FormData>({
    resolver: zodResolver(schema),
  });

  const onSubmit = async (data: FormData) => {
    await serverAction(data);
  };

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      <input {...register("email")} />
      {errors.email && <span>{errors.email.message}</span>}
      <button type="submit">Submit</button>
    </form>
  );
}

Commands

# Development
cd ui && pnpm install
cd ui && pnpm run dev

# Code Quality
cd ui && pnpm run typecheck
cd ui && pnpm run lint:fix
cd ui && pnpm run format:write
cd ui && pnpm run healthcheck    # typecheck + lint:check + format:check
cd ui && pnpm run lint:knip      # unused files/exports

# Testing
cd ui && pnpm run test:unit          # Vitest jsdom
cd ui && pnpm run test:integration   # Vitest browser mode (Chrom

---

*Content truncated.*

When not to use it

  • →Adding legacy HeroUI components
  • →Generic web development unrelated to Prowler UI

Limitations

  • →No support for adding legacy HeroUI
  • →Strict file naming and placement conventions
  • →Requires use of Next.js 16/React 19 conventions

How it compares

It restricts development to specific library versions and architecture patterns, maintaining design consistency across the Prowler UI.

Compared to similar skills

prowler-ui side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
prowler-ui (this skill)15moReviewIntermediate
implementing-figma-ui-tempad-dev08moNo flagsIntermediate
landing-page-guide-v2481yReviewIntermediate
frontend-prompt-generator61yReviewIntermediate

Try saying

Example prompts that trigger this skill in your AI assistant.

You might also like

implementing-figma-ui-tempad-dev

ecomfe

Implement integration-ready UI code from a Figma selection or a provided nodeId using TemPad Dev MCP as the only source of design evidence (code snapshot, structure, screenshot, assets, tokens, codegen config). Detect the target repo stack and conventions first, then translate TemPad Dev’s Tailwind-like JSX/Vue IR into project-native code without adding new dependencies. Never guess key styles or measurements; avoid screenshot tuning loops. If required evidence is missing/contradictory or assets cannot be handled under repo policy, stop or ship a safe base with explicit warnings and omissions.

00

landing-page-guide-v2

bear2u

Create distinctive, high-converting landing pages that combine proven conversion elements with exceptional design quality. Build beautiful, memorable landing pages using Next.js 14+ and ShadCN UI that avoid generic AI aesthetics while following the 11 essential elements framework.

48105

frontend-prompt-generator

gharam1234

Generate structured prompts for frontend development tasks following established patterns. Use when the user requests prompts for wireframes, UI implementation, data binding, or routing functionality in React/Next.js projects with specific formatting requirements (Cursor rules, file paths, test-driven development).

679

figma-implement-design

openai

Translate Figma nodes into production-ready code with 1:1 visual fidelity using the Figma MCP workflow (design context, screenshots, assets, and project-convention translation). Trigger when the user provides Figma URLs or node IDs, or asks to implement designs or components that must match Figma specs. Requires a working Figma MCP server connection.

2460

ai-sdk-5

prowler-cloud

Vercel AI SDK 5 patterns. Trigger: When building AI features with AI SDK v5 (chat, streaming, tools/function calling, UIMessage parts), including migration from v4.

316

react-nextjs-development

netbarros

React and Next.js 14+ application development with App Router, Server Components, TypeScript, Tailwind CSS, and modern frontend patterns.

00

Search skills

Search the agent skills registry