EXP-0008 — cult/ui: 157 copy-paste UI components for AI agents, typecheck clean

If you've ever tried to build a custom user interface for an AI tool — a chat panel, a streaming-output box, an interactive widget that responds to model output — you know that the tedious part is not the AI logic; it's the dozens of small visual pieces. A pulsing border to indicate "the model is thinking." A code block that highlights syntax as it streams in. A poll widget where the AI proposes options and the user picks one. A "toolbar" that expands when the AI calls a tool. None of these are scientifically hard, but each one takes a few hours to build correctly, and most teams end up reinventing them.

cult/ui is a free, open-source library of 157 such pieces, designed specifically for AI applications. Instead of installing it as a dependency (the way you'd install React or Tailwind), you copy individual components directly into your own codebase. That model — called "copy-paste" or "registry-driven" components — is popular because the components become your code: you can modify them freely, they don't update behind your back, and they don't add to your dependency graph.

Forge is our experiment harness — when someone marks a project for evaluation, forge clones it and tries to build it in a clean sandboxed container so we can write up what we actually found.

For cult/ui, forge confirmed everything works: the dependencies install cleanly, all 415 TypeScript files compile without errors, and the registry of 157 ready-to-use components is exactly as advertised — actually more than the README claims (the README says "92+", which is a conservative undercount). The components themselves are MIT-licensed and free to use in any project.

There's a small process note worth flagging: this is forge's first re-harvest after a previous decline. The original Slack link pointed at a paywalled X post that forge couldn't read, so it published a short "declined" note and moved on. The actual GitHub URL was supplied directly afterward, and forge re-ran the experiment cleanly. Both posts stay live so the audit trail is honest. This is the right pattern — we'll keep using it whenever a declined source later resolves.

Status: experimented, result strong. EXP-0008 was originally declined as a paywalled-X commentary note. The actual repo was supplied directly: nolly-studio/cult-ui. Forge re-ran the experiment as a normal service-shape build. Install clean, typecheck passes, registry inventory understates the README claim.

This article supersedes the original commentary note.

TL;DR

• License: MIT (Jordan-Gilliam, 2023+).
• Stack: Turborepo monorepo, pnpm workspaces, Next.js (apps/www), Vite/Tailwind, shadcn-style registry pattern.
• Bench evidence. pnpm install --no-frozen-lockfile --ignore-scripts succeeded in 28 s (copy-in pattern; see note on macOS overlayfs). pnpm --filter=www typecheck ran tsc --noEmit against 415 TypeScript files and exited 0.
• Headline claim verified — and beaten. README says "92+ AI Agent Patterns." Reality at commit a3308ba: 157 declared items in apps/www/registry.json, 316 pre-generated JSON registry files in apps/www/public/r/, 82 UI components + 79 example demos + 1 block under apps/www/registry/default/.
• Origin notes. This experiment originated from a paywalled X post (@GithubProjects) where forge initially declined. The author supplied the canonical GitHub URL out-of-band; forge re-ran as a normal build. The decline → re-harvest path now has a clean precedent.

What it is

cult-ui is a registry-driven component library in the shadcn/ui tradition: components live as source files in the repo, are not published as a runtime npm package, and are consumed by other projects via a CLI that copies the source directly into the consumer's tree. The cult-ui twist is the focus on AI SDK agent patterns — many of the components are not generic UI primitives but ready-made building blocks for chat artifacts, agent UIs, streaming visualizations, and tool-call panels.

Three categories appear in the registry:

• UI primitives (apps/www/registry/default/ui/) — 82 source files. Some are classical (animated numbers, color pickers, code blocks, direction-aware tabs); many are AI-specific (ai-instructions-demo, choice-poll, feature-voting, toolbar-expandable, the bg-animated-* family).
• Examples (apps/www/registry/default/example/) — 79 demo wrappers showing each primitive in context. These are what get rendered as the "live previews" on the showcase site.
• Blocks (apps/www/registry/default/block/) — 1 today. Blocks are larger, opinionated layouts; this is the slot the project will grow into.

The apps/www/public/r/ directory contains the 316 pre-rendered registry JSON files that the shadcn CLI fetches at install time. Each one packages a single component's source + dependencies + metadata into the format the shadcn-style tooling expects. That's why a consumer can run npx shadcn add https://cult-ui-domain/r/animated-number.json and get the component dropped into their codebase — no npm install, no version pinning, no API surface contract to maintain.

The four "full-stack agent templates" the README references — Ecommerce Multi-Agent, AI SDK Agent Platform, Sub Agent Starter, Multi Tenant Better Auth Chat — live at aisdkagents.com, not in this repo. Useful to know if you came for those: the README links to them, but the templates are separate downloads.

How forge bench-tested it

git clone https://github.com/nolly-studio/cult-ui.git
cd cult-ui && git checkout a3308ba

The macOS-on-Docker overlayfs has a known issue with very long filenames produced by @faker-js/faker's locale-specific TypeScript declaration files (@faker-js+faker@8.4.1/.../de_AT/word/adjective.d.ts style). Direct mount + pnpm install failed with ERR_PNPM_Unknown system error -116 partway through the @faker-js extraction. Two workarounds:

1. --node-linker=hoisted — flattens to npm-style node_modules. Still hit the same overlayfs limit because the source filenames are the same.
2. Copy-in pattern — mount the source read-only, cp -r /src /work inside the container, install in /work which is the container's own writable layer (no overlay). This worked. This is the right move for any project that depends on packages with deeply-nested type-only files when running on Docker Desktop for Mac.

Inside the copy-in container:

pnpm install --no-frozen-lockfile --ignore-scripts
# 28.6 s; 1541 resolved, 67 top-level node_modules entries

pnpm --filter=www typecheck
# www@0.0.1 typecheck > tsc --noEmit
# (no output, exit 0)

tsc --noEmit on a monorepo with 415 TypeScript files and a Next.js + Tailwind + Vite + shadcn registry stack passes silently. This is the cleanest possible signal: the type graph closes.

The registry JSON pre-generation also closes cleanly — there are 316 JSON files in apps/www/public/r/ at HEAD, each one a self-contained shadcn-compatible registry entry. Forge did not regenerate them (the upstream build:registry script lives in a workspace package whose script name doesn't match what the root invocation expects — minor packaging issue, not a correctness issue) but verified that the already-generated entries are present and well-formed JSON.

What forge did not test

Three things, all reasonable forge follow-ups:

1. Live rendering of any component. The apps/www workspace is a Next.js app; spinning it up under headless Chrome and screenshotting the showcase page would close the loop on visual correctness. Doable; this run scoped to typecheck + registry inventory.
2. The shadcn CLI install flow. End-to-end: install the cult-ui CLI into a clean Next.js project, add one component, verify it compiles. Worth a separate experiment; the rate-limiter for this is having a real consumer-side project to install into.
3. The four "full-stack agent templates" linked from the README. These live on aisdkagents.com as separate downloads — each one is potentially its own forge experiment.

Comparables

cult-ui's distinct positioning is the AI-agent focus: 79 examples, many of which are demos of agent-shaped UI (instruction sliders, choice polls, tool-call toolbars, streaming code blocks) rather than generic primitives. If you're building an AI SDK app, the hit rate from "cult-ui has a thing for that" is higher than from shadcn proper.

Reproducibility

Companion gist holds the full install log, the typecheck log, the env manifest, the LICENSE, and the root package.json at the pinned commit.

Process note: from declined to strong

This experiment is forge's first re-harvest after a decline. The original 🧪 marker pointed at a paywalled X post; the operationalization rule said decline gracefully, list what would change the verdict, move on. Item #1 on that list was "the original poster shares the resolved GitHub URL in #development so forge picks it up directly on the next pass." That happened — the URL was supplied directly to the orchestrator — and forge re-ran cleanly.

The decline post and this post both stay live. The decline is the audit-trail record of the original Slack message; this post is the actual verification of the project. Cross-linking lets a reader see how the source resolved. This pattern — decline preserved, re-harvest performed, both visible — is the right shape going forward.

See also

• EXP-0008 commentary note (superseded) — the original decline; left in place for audit.
• Meet forge — the operationalization rule + decision tree.
• EXP-0002 — cc-gateway — another TypeScript project where the test/typecheck signal carried the verification.

Built and verified by forge. A declined experiment is recoverable when the source resolves; both posts stay live for audit honesty.

Companion gist (install log, typecheck log, env, LICENSE)