Skills from clawhub.ai/wpank

Design and implement event stores for event-sourced systems. Use when building event sourcing infrastructure, implementing event persistence, projections, snapshotting, or CQRS patterns.

Rate limiting algorithms, implementation strategies, HTTP conventions, tiered limits, distributed patterns, and client-side handling. Use when protecting APIs from abuse, implementing usage tiers, or configuring gateway-level throttling.

When the user wants to add illustrations to an article or blog post. Triggers on: "illustrate article", "add images to article", "generate illustrations", "article images", or requests to visually enhance written content. Analyzes article structure, identifies positions for visual aids, and generates illustrations using a Type x Style two-dimension approach.

Get an independent risk assessment for any proposed Uniswap operation — swap, LP position, bridge, or token interaction. Evaluates slippage, impermanent loss, liquidity, smart contract, and bridge risks with a clear APPROVE or VETO decision. Use when the user asks if something is safe or wants a risk evaluation.

Provides documentation on error-handling patterns, retry strategies, circuit breakers, and middleware patterns. Contains installation shell commands such as `npx add https://github.com/wpank/ai/tree/main/skills/api/error-handling` and copy instructions like `cp -r ~/.ai-skills/skills/api/error-handling .cursor/skills/error-handling`.

Pragmatic coding standards for writing clean, maintainable code — naming, functions, structure, anti-patterns, and pre-edit safety checks. Use when writing new code, refactoring existing code, reviewing code quality, or establishing coding standards.

Provides backend architecture patterns, templates, and example code for Clean Architecture, Hexagonal, and Domain-Driven Design. Contains examples that call external services (`this.stripe.paymentIntents.create`), reference `process.env.SENDGRID_KEY`, and include runnable commands like `python search.py` and `npx add https://github.com/wpank/ai/tree/main/skills/backend/architecture-patterns`.

Facilitate over-the-counter trades between agents using Uniswap as the settlement layer. Use when user wants to trade tokens directly with another agent, settle an agent-to-agent trade through Uniswap, or execute an OTC swap with a specific counterparty agent. Verifies counterparty identity via ERC-8004, negotiates terms, and settles through Uniswap pools.

Comprehensive analysis of Uniswap Firepit burn economics: historical burn P&L, accumulation trends, fee source breakdown, competitive dynamics, and profitability projections. Governance-grade research report. Use when user asks "What's the burn economics?", "History of protocol fee burns", or "Average profit per burn."

Meta-skill that orchestrates the full API development lifecycle — from design through documentation — by coordinating specialized skills, agents, and commands into a seamless build workflow.

Patterns for animating financial numbers with spring physics, formatting, and visual feedback. Covers animated counters, price tickers, percentage changes, and value flash effects. Use when building financial dashboards or trading UIs. Triggers on animated number, price animation, financial display, number formatting, spring animation, value ticker.

Analyze a specific Uniswap pool's performance, liquidity depth, fee APY, and risk factors. Use when the user asks about pool metrics, TVL, volume, or whether a pool is good for LPing.

Simulate and analyze Uniswap swaps including price impact, slippage, optimal routing, and gas estimation. Use when the user asks about swap execution, routing, price impact, or MEV considerations.

api-design-principles

architecture-decision-records-adrs

This skill documents development-velocity patterns and includes installation and local setup instructions. It contains executable install commands (`npx clawhub@latest install 10x-patterns`, `npx add https://github.com/wpank/ai/tree/main/skills/meta/10x-patterns`) and directs copying into agent folders like `.claude/skills`.

Bridge tokens from one chain to another without swapping. Simplified cross-chain transfer where the output token is the same as the input token. Use when the user wants to move tokens between chains.

Deploy a custom Uniswap pool on the local testnet with configurable parameters. Create pools with specific conditions (thin liquidity, wide spreads, exact tick ranges) to test agent behavior under controlled scenarios. Requires a running local testnet.

Provides guidelines, templates, and runnable examples for clear technical writing plus installation steps. Installation includes explicit shell commands like `npx add https://github.com/wpank/ai/tree/main/skills/writing/clear-writing` and `cp -r ~/.ai-skills/skills/writing/clear-writing .claude/skills/clear-writing`, and sample code calls `https://api.example.com`.

Complete workflow for creating distinctive design systems from scratch. Orchestrates aesthetic documentation, token architecture, components, and motion. Use when starting a new design system or refactoring an existing one. Triggers on create design system, design tokens, design system setup, visual identity, theming.

Find 10x product opportunities and high-leverage improvements. Use when the user wants strategic product thinking, mentions 10x, wants to find high-impact features, or asks what would make a product dramatically more valuable.

Create persona documentation for a product or codebase. Use when asked to create persona docs, document target users, define user journeys, document onboarding flows, or when starting a new product and needing to define its audience. Persona docs should be the first documentation created for any product.

API versioning strategies — URL path, header, query param, content negotiation — with breaking change classification, deprecation timelines, migration patterns, and multi-version support. Use when evolving APIs, planning breaking changes, or managing version lifecycles.

Builds a Uniswap V4 hook, generating Solidity, Foundry tests, CREATE2 salts, and deployment scripts. The skill contains explicit shell commands that download-and-run a remote installer (`curl -L https://foundry.paradigm.xyz \| bash`) and references fetching the skill via `https://github.com/wpank/Agentic-Uniswap/tree/main/.ai/skills/build-hook`.

Design a Uniswap V4 hook architecture without code generation. Use when user wants to plan a hook, understand which callbacks to use, or review an architecture before building. Returns a design document, not code.

Execute a cross-chain token swap via Uniswap's bridge infrastructure. Handles quoting, safety validation, bridge monitoring, and destination confirmation. Use when the user wants to swap tokens across different chains.

Safe, zero-downtime database migration strategies — schema evolution, rollback planning, data migration, tooling, and anti-pattern avoidance for production systems. Use when planning schema changes, writing migrations, or reviewing migration safety.

Find and execute cross-chain arbitrage opportunities. Scans prices across all chains, evaluates profitability after all costs (gas, bridge fees, slippage), assesses risk, and executes if profitable. Uses ERC-7683 for cross-chain settlement. Supports scan-only mode for research without execution.

This skill manages project context artifacts such as `context/product.md`, `context/tech-stack.md`, `context/workflow.md`, and `context/tracks.md` to support AI-assisted development. It includes installation commands (`npx clawhub@latest install context-driven-development`, `npx add https://github.com/wpank/ai/tree/main/skills/meta/context-driven-development`) that run shell commands and fetch from the network.

Extract design systems, architecture patterns, and methodology from codebases into reusable skills and documentation. Use when analyzing a project to capture patterns, creating skills from existing code, extracting design tokens, or documenting how a project was built. Triggers on "extract patterns", "extract from this repo", "analyze this codebase", "create skills from this project", "extract design system".

Patterns for building dark-themed financial charts and data visualizations. Covers chart theming, color scales for gains/losses, and real-time data display. Use when building trading dashboards or financial analytics. Triggers on chart theme, data visualization, financial chart, dark theme, gains losses, trading UI.

Provides patterns for building distinctive design systems, including CSS variables, Tailwind configuration, and TypeScript tokens. Installation instructions fetch `https://github.com/wpank/ai/tree/main/skills/design-systems/distinctive-design-systems` and instruct running `npx add`, `mkdir -p .cursor/skills`, and copying into `~/.claude/skills`.

Meta-skill for orchestrating end-to-end feature development from persona research through deployed, tested code — coordinating skills, commands, and agents across every stage. Use when building a new feature end-to-end, coordinating frontend + backend work, or needing a structured approach from research to production.

PostgreSQL-based job queue with priority scheduling, batch claiming, and progress tracking. Use when building job queues without external dependencies. Triggers on PostgreSQL job queue, background jobs, task queue, priority queue, SKIP LOCKED.

Meta-skill that orchestrates logging, monitoring, error handling, performance, security, deployment, and testing skills to ensure a service is fully production-ready before launch. Use before first deploy, major releases, quarterly reviews, or after incidents.

High-risk monorepo management skill covering Turborepo, Nx, and pnpm setup. It instructs `npx turbo login`/`npx turbo link`, configures `globalDependencies` like `**/.env.*local`, and uses `GITHUB_TOKEN`/`NPM_TOKEN`, which can cause secrets to be included in shared remote cache.

Dangerous skill: contains an example API that returns `process.env.API_URL`, exposing environment variables and enabling secret leakage. It documents shell commands (`PORT=3001 node .next/standalone/server.js &`), network calls (`https://api.example.com/posts`, `https://res.cloudinary.com/...`), and installation steps copying into `~/.claude/skills`.

This skill implements file-based planning using `task_plan.md`, `findings.md`, and `progress.md` with templates and helper scripts. It includes explicit shell commands (e.g., `./scripts/init-session.sh`, `npx ...`), network install URLs such as `https://github.com/wpank/ai/tree/main/skills/meta/planning-with-files`, and instructions to copy into `.claude/skills`.

Provides authentication and authorization patterns for JWT, OAuth 2.0, sessions, RBAC/ABAC, password security, and MFA. Includes install instructions such as `npx add https://github.com/wpank/ai/tree/main/skills/api/auth-patterns` and `cp -r ~/.ai-skills/skills/api/auth-patterns .cursor/skills/auth-patterns` that invoke network fetches and filesystem operations.

Caching strategies, invalidation, eviction policies, HTTP caching, distributed caching, and anti-patterns. Use when designing cache layers, choosing eviction policies, debugging stale data, or optimizing read-heavy workloads.

Compare all Uniswap pools for a token pair across fee tiers and versions. Use when the user asks which pool is best, wants to compare V3 vs V4, or wants to find the optimal fee tier.

This skill auto-loads project context files (e.g., `TODO.md`, `roadmap.md`) to build situational awareness before actions. It includes explicit shell commands such as `stat ...` and an installation URL `https://github.com/wpank/ai/tree/main/skills/meta/auto-context`, which enable local shell execution and network fetches.

Configure x402 micropayments for agent-to-agent commerce via Uniswap. Set up your agent to pay per MCP request in USDC on Base (~200ms settlement) or accept x402 payments as a service provider. Use when the user wants to enable pay-per-use API access or monetize their agent's services.

react-composition-patterns

Structured decision-making patterns for common engineering choices — library selection, architecture, build vs buy, prioritization, reversibility analysis, and ADRs. Use when choosing between tools, architectures, or approaches, or when documenting technical decisions.

Provides a structured `code-review` checklist and installation instructions for reviewing PRs. Installation instructs running `npx` commands like `npx clawhub@latest install code-review`, fetching `https://github.com/wpank/ai/tree/main/skills/testing/code-review`, and copying files into agent config paths such as `.claude/skills`.

This skill creates Claude Code slash commands and writes files into `.claude/commands/` or `~/.claude/commands/`. It contains explicit instructions to run shell commands (e.g., `make all-ci`, `git commit`) and to fetch code with `npx add https://github.com/wpank/ai/tree/main/skills/tools/command-creator`.

Design a Uniswap integration architecture. Use when user is building a project that needs to integrate Uniswap and wants recommendations on integration method (Trading API vs SDK vs direct contract), architecture patterns, required dependencies, and security considerations.

Foundational design system architecture — token hierarchies, theming infrastructure, token pipelines, and governance. Use when creating design tokens, implementing theme switching, setting up Style Dictionary, or establishing multi-brand theming. Triggers on design tokens, theme provider, Style Dictionary, token pipeline, multi-brand theming, CSS custom properties architecture.

Convert persona docs into detailed feature specifications with acceptance criteria. Use when translating user needs into implementable specs, writing user stories, defining acceptance criteria, or preparing features for development.

Dual-stream event publishing combining Kafka for durability with Redis Pub/Sub for real-time delivery. Use when building event-driven systems needing both guaranteed delivery and low-latency updates. Triggers on dual stream, event publishing, Kafka Redis, real-time events, pub/sub, streaming architecture.

This skill automates launching a token and creating a Uniswap V4 pool with configurable hooks, liquidity bootstrapping, LP locking, and monitoring. It instructs running `npx skills add https://github.com/wpank/Agentic-Uniswap/tree/main/.ai/skills/deploy-agent-token` and delegating to `Task(subagent_type:token-deployer)`, which performs network/blockchain operations.

This skill provides React design-system component patterns using CVA and Surface primitives. It includes installation instructions that fetch `https://github.com/wpank/ai/tree/main/skills/design-systems/design-system-components` and direct copying into ` .claude/skills` and `.cursor/skills`.

Create distinctive, production-grade frontend interfaces that avoid generic "AI slop" aesthetics. Focuses on creative direction and memorable design choices.

Find the highest-yield LP pools on Uniswap filtered by risk tolerance and minimum TVL. Use when the user asks about the best yields, highest APY pools, or where to earn fees.

This skill documents E2E testing patterns for Playwright and Cypress, including config, fixtures, CI, and debugging. It contains explicit shell commands like `npx clawhub@latest install e2e-testing-patterns`, references `https://github.com/wpank/ai/tree/main/skills/testing/e2e-testing-patterns`, and uses `process.env.CI` in examples.

Production Go concurrency patterns — goroutines, channels, sync primitives, context, worker pools, pipelines, and graceful shutdown. Use when building concurrent Go applications or debugging race conditions.

This skill documents practical estimation techniques for software planning and provides installation instructions. It includes shell commands such as `npx clawhub@latest install estimation-patterns` and `cp -r ~/.ai-skills/skills/meta/estimation-patterns .cursor/skills/estimation-patterns`, and references `https://github.com/wpank/ai/tree/main/skills/meta/estimation-patterns`.

Comprehensive LP strategy comparison for a token pair — evaluates all versions, fee tiers, range widths, and rebalance approaches side-by-side with APY, IL, gas costs, and risk ratings. Use when the user wants to compare LP options or see a detailed analysis of all strategies.

This skill provides guidance and example files for building Expo Router mobile apps with native tabs, visual effects, and WebGPU/Three.js. It instructs running shell commands like `npx expo start` and `npx clawhub@latest install expo-native-ui`, pulls from `https://github.com/wpank/ai/tree/main/skills/frontend/expo-native-ui`, and copies files into `~/.claude/skills` and `.cursor/skills`.

This skill helps finish a development branch by verifying tests, generating merge summaries, and offering actions to merge, create a PR, keep, or discard work. It executes local shell commands (e.g., `git`, test runners), performs network operations to `origin` and `https://github.com/wpank/ai/tree/main/skills/tools/finishing-branch`, and instructs installing into agent dirs like `~/.claude/skills`.

Monitor the Uniswap TokenJar with a real-time dashboard showing balances, accumulation rates, burn economics, and projected time to next profitable burn. Supports one-shot snapshot and streaming modes. Use when user asks "Watch the TokenJar", "Track fee accumulation", or "When is the next profitable burn?"

This skill manages Uniswap liquidity operations (add/remove/collect) and delegates execution to subagents. It requires `WALLET_TYPE`/`PRIVATE_KEY` in `.env` and calls `mcp__uniswap__get_positions_by_owner`, `mcp__uniswap__get_position`, and `mcp__uniswap__check_safety_status`.

Provides Mermaid diagram guidance, examples, and install/export instructions. Includes explicit shell commands (`npx`, `npm install -g`, `mmdc`), external imports (`https://cdn.jsdelivr.net/...`, `https://github.com/...`), and install steps that write to `~/.claude/skills` and `~/.cursor/skills`.

This skill documents building native mobile UIs with Expo Router and React Native. It includes explicit shell commands like `npx expo start` and `npm install ...` and network install URLs such as `https://github.com/wpank/ai/tree/main/skills/frontend/native-ui`.

React and Next.js performance optimization guidelines from Vercel Engineering. 57 rules across 8 categories for writing, reviewing, and refactoring React code.

Controller-service-query layered API architecture with data enrichment and parallel fetching. Use when building REST APIs or GraphQL resolvers with clean separation of concerns. Triggers on API architecture, service layer, controller pattern, data enrichment, REST API.

Analyze TokenJar profitability and optionally execute a Firepit burn-and-claim. Autonomous pipeline: checks balances, prices assets, calculates profit vs. 4,000 UNI burn cost, simulates, and executes if profitable. Default is preview-only. Use when user asks "Is the TokenJar profitable?", "Execute a burn", or "Claim protocol fees."

Unit, integration, and E2E testing patterns with framework-specific guidance. Use when asked to "write tests", "add test coverage", "testing strategy", "test this function", "create test suite", "fix flaky tests", or "improve test quality".

tailwind-design-system

Patterns for skeleton loaders, shimmer effects, and loading states that match design system aesthetics. Covers skeleton components, shimmer animations, and progressive loading. Use when building polished loading experiences. Triggers on skeleton, loading state, shimmer, placeholder, loading animation.

This skill orchestrates a full LP workflow: scanning pools, designing strategies, assessing risk, and (with user confirmation) executing swaps and adding liquidity. It requires wallet interaction and calls `mcp__uniswap__check_safety_status` and `mcp__uniswap__get_agent_balance`.

microservices-patterns

Provides guidance for structured logging, OpenTelemetry tracing, and metrics (RED/USE) with examples for Prometheus/Grafana. Includes installer shell commands like `npx add https://github.com/wpank/ai/tree/main/skills/tools/logging-observability` and an OTLP exporter URL `http://otel-collector:4318/v1/traces`.

React composition patterns for scalable component architecture. Use when refactoring components with boolean prop proliferation, building flexible component libraries, designing reusable component APIs, or working with compound components and context providers.

Patterns for building resilient API clients and real-time connections with retry logic, circuit breakers, and graceful degradation. Use when building production systems that need to handle failures. Triggers on retry logic, circuit breaker, connection resilience, exponential backoff, API client, fault tolerance.

Research a token and execute a trade if it passes due diligence. Autonomous research-to-trade pipeline: researches the token, evaluates risk, and only trades if the risk assessment approves. Stops and reports if risk is too high. Use when user wants "research X and buy if it looks good" or "due diligence then trade."

Add, fix, or optimize schema markup and structured data. Use when the user mentions schema markup, structured data, JSON-LD, rich snippets, schema.org, FAQ schema, product schema, review schema, or breadcrumb schema.

Research a token's Uniswap liquidity, volume profile, pool distribution, and risk factors. Use when the user asks about a token's tradability, liquidity depth, or wants due diligence.

This skill provides Prometheus production configuration, templates, recording and alerting rules, and deployment guidance. It includes shell commands like `helm install` and `promtool`, network endpoints such as `https://prometheus-community.github.io/helm-charts`, and references secret files like `/var/run/secrets/kubernetes.io/serviceaccount/token`.

Set up a non-custodial dollar-cost averaging strategy on Uniswap. Use when user wants to create recurring swaps, auto-buy ETH/BTC/SOL with USDC on a schedule, or build a DCA bot. Covers USDC approval, swap path selection, frequency configuration, Gelato keeper automation, and monitoring. Works on local testnet for development or mainnet for production.

Use when executing implementation plans with independent tasks in the current session

Meta-skill that orchestrates comprehensive testing across a project by coordinating testing-patterns, e2e-testing, and testing agents. Use when setting up testing for a new project, improving coverage for an existing project, establishing a testing strategy, or verifying quality before a release.

Searchable UI/UX design database with a CLI that generates and persists design systems via `python3 scripts/search.py`. Documentation instructs network installs like `npx add https://github.com/wpank/ai/tree/main/skills/design-systems/ui-ux-pro-max`, writing `design-system/MASTER.md`, and copying the skill into agent folders such as `.claude/skills`.

Get the optimal LP strategy for a token pair — recommends version (V2/V3/V4), fee tier, range width, and rebalance approach based on pair characteristics, historical data, and risk tolerance. Use when the user asks how to LP, what range to use, or which version/fee tier is best.

Generate a comprehensive portfolio report for a wallet's Uniswap positions across all chains — covering total value, PnL, fee earnings, impermanent loss, and composition. Use when the user asks about their positions, earnings, or portfolio overview.

Set up a complete self-funding agent lifecycle in one command. Orchestrates 5 agents to take an agent from zero to self-sustaining: provisions wallet, optionally deploys token with V4 pool, configures treasury management, registers identity on ERC-8004, and sets up x402 micropayments. Use when user wants to make their agent self-funding, earn and manage its own revenue, or configure autonomous agent operations end-to-end.

Set up an agent wallet for Uniswap operations. Use when user needs to provision a wallet for an autonomous agent. Supports Privy (development), Turnkey (production), and Safe (maximum security). Configures spending limits, token allowlists, and funds the wallet for gas.

This skill provides guidance and a checklist to minimize codebase size through ruthless simplification and deletion. It includes installation steps that run `npx add https://github.com/wpank/ai/tree/main/skills/testing/reducing-entropy` and `cp -r`, which instruct shell execution and fetch code remotely.

This skill automates release workflows: detecting version files, bumping versions, generating changelogs, tagging, and pushing releases. It includes scripts and shell instructions that run `git` commands (`git commit`, `git tag`, `git push`), fetch/install via `npx` (`https://github.com/.../release-skills`), and write into agent skill directories (`.claude/skills`, `~/.cursor/skills`).

Track the performance of Uniswap LP positions over time — check which positions need attention, are out of range, or have uncollected fees. Use when the user asks how their positions are doing.

Provides workflows and templates for project documentation. Contains explicit installation steps that run shell commands (`npx clawhub@latest install project-documentation`, `cp -r ~/.ai-skills/skills/meta/project-documentation .claude/skills/project-documentation`) and fetch code from `https://github.com/wpank/ai/tree/main/skills/meta/project-documentation`.

Complete guide to building real-time dashboards with streaming data, WebSocket/SSE, and live updates. Orchestrates dual-stream architecture, React hooks, and data visualization. Use when building trading dashboards, monitoring UIs, or live analytics. Triggers on realtime dashboard, live data, streaming dashboard, trading UI, monitoring.

React and Next.js performance optimization patterns. Use when writing, reviewing, or refactoring React/Next.js code to ensure optimal performance. Triggers on tasks involving components, data fetching, bundle optimization, re-render reduction, or server component architecture.

react-modernization

React hooks for real-time data with SSE, WebSocket, and SWR integration. Covers connection management, reconnection logic, and optimistic updates. Use when building React apps with real-time features. Triggers on SSE hook, WebSocket hook, real-time React, useEventSource, live updates.

This skill provides templates and guidance for professional technical messages. It includes explicit installation steps that run `npx` commands, fetch `https://github.com/wpank/ai/tree/main/skills/writing/professional-communication`, and copy files into `~/.claude/skills`, instructing shell execution, network fetches, and modification of agent skill directories.

Rebalance an out-of-range Uniswap V3/V4 LP position by closing the old position and opening a new one centered on the current price. Handles fee collection, removal, range calculation, and re-entry in a single workflow. Use when a position is out of range and needs adjustment.

responsive-design

Scan for LP opportunities, arbitrage, and high-yield pools across all Uniswap deployments. Use when the user asks about the best opportunities, high-yield pools, or arbitrage.

tailwind-v4-shadcn-ui-stack

This skill documents quality gates and provides CI and install instructions. It includes shell commands (`npx`, `cp`, `.git/hooks/pre-commit`), network URLs (`https://github.com/wpank/ai/tree/main/skills/testing/quality-gates`), and directs copying into agent config paths (`.claude/skills`).

Track, calculate, and optimize key performance metrics for startups from seed through Series A. Covers unit economics, growth efficiency, and business models.

Spins up a local Anvil testnet forked from a live chain with Uniswap deployed and seeded accounts. The skill includes shell/network install commands (e.g. `curl -L https://foundry.paradigm.xyz | bash && foundryup`, `npx ...`) and exposes test private keys and `RPC_URL_1` for `.env`.

Comprehensive UI design skill covering fundamentals, patterns, and anti-patterns. Layout, typography, color, spacing, accessibility, motion, and component design. Use when building any web interface, reviewing design quality, or creating distinctive UIs.

Horizontally-scalable WebSocket hub pattern with lazy Redis subscriptions, connection registry, and graceful shutdown. Use when building real-time WebSocket servers that scale across multiple instances. Triggers on WebSocket hub, WebSocket scaling, connection registry, Redis WebSocket, real-time gateway, horizontal scaling.

CSS implementation patterns for layout, typography, color, spacing, and responsive design. Complements ui-design (fundamentals) with code-focused examples.

Creates and manages session handoff documents with scripts to scaffold, validate, list, and check staleness. Contains executable scripts that invoke `subprocess.run` and ask the user to run `python scripts/create_handoff.py`, install via `npx add https://github.com/wpank/ai/tree/main/skills/tools/session-handoff`, check env with `env | grep [relevant-var]`, and copy into `.claude/skills`.

Analyze Uniswap pool data including liquidity distribution, fee tiers, tick ranges, and TVL. Use when the user asks about pool metrics, liquidity analysis, or wants to query on-chain pool state.

Systematic task implementation using TDD, phase checkpoints, and structured commits. Ensures quality through red-green-refactor cycles, 80% coverage gates, and verification protocols before proceeding.

This skill documents how to install and use `shadcn/ui` components for Next.js and Tailwind projects. It includes explicit install commands like `npx shadcn@latest add` and file operations that copy into agent directories such as `~/.claude/skills`, which modify local files and perform network installs.

Theme Factory provides 10 curated visual themes and guidance for applying them, reading theme files from `themes/` and supplying CSS and contrast rules. The package includes installation commands such as `npx add https://github.com/wpank/ai/tree/main/skills/design-systems/theme-factory` and `cp -r ~/.ai-skills/skills/design-systems/theme-factory .cursor/skills/theme-factory` that invoke shell and network actions; no secret access or obfuscated code is present.