sickn33/antigravity-awesome-skills
311 skills294k installs12M starsGitHub
Install
npx skills add https://github.com/sickn33/antigravity-awesome-skillsSkills in this repo
1Docker ExpertDocker Expert is an agent skill that acts as a hands-on containerization consultant for solo and indie builders shipping web apps, APIs, and CLIs. It is meant when you are writing or refining Dockerfiles, tightening image size and build times, applying security hardening, or planning how containers behave in production—not when you need full Kubernetes ingress design or cloud-specific ECS/Fargate runbooks, which the skill explicitly defers to other experts. Invocation starts with scoping: if the problem is K8s pods, GitHub Actions CI, AWS container services, or complex database persistence, it tells you to switch agents and stops. For in-scope Docker work, it prefers repository inspection via internal tools, then systematic analysis of your container setup against practical optimization and deployment patterns. Use it during Build when you first containerize, during Ship when you prep a secure release artifact, and during Operate when you iterate on runtime images—without replacing a dedicated platform team.18.7kinstalls2Nodejs Best PracticesNode.js Best Practices is an agent skill for solo and indie builders who need sound server-side decisions instead of defaulting to Express every time. It walks through when to use edge-oriented Hono, performance-focused Fastify, structured NestJS, mature Express, or full-stack Next.js and tRPC routes, with comparison axes like cold start, ecosystem, and team familiarity. The skill stresses decision-making: clarify user constraints, pick patterns for async I/O, security, and deployment context, and avoid one-size-fits-all templates. Use it when scaffolding a new API, revisiting framework choice before scale, or pairing architecture reviews with shipping and operate work. It fits agents in Claude Code, Cursor, and Codex when the repo is Node/TypeScript and the task is design judgment, not a single integration recipe.11.7kinstalls3Typescript ExpertTypescript-expert encodes a production-grade strict TypeScript 5.x compiler profile for solo builders shipping SaaS, CLIs, or APIs with agent assistance. The skill centers on a JSON Schema–validated tsconfig that turns on full strict mode plus indexed-access and optional-property rigor, so autocomplete and refactors do not silently widen types. It standardizes on ESNext modules with bundler resolution, interop flags, and verbatim module syntax—matching Vite, Next, and similar toolchains indie developers use daily. Declaration emit and source maps support publishable packages and debuggable builds. Install it when you want agents to stop proposing loose tsconfig snippets and instead align every new file with one hardened baseline before feature work or library extraction.9kinstalls4Clean CodeClean Code is an agent skill that encodes Robert C. Martin’s Clean Code principles so your coding agent does not stop at “it compiles.” Solo builders use it when they write features themselves, when they ask an agent to implement a spec, or when they review diffs before shipping. The skill pushes intention-revealing names, honest data structures, tiny functions that do one thing, and review feedback framed as industry-standard smells rather than taste arguments. It fits indie workflows where you are simultaneously author and reviewer: invoke during implementation to prevent debt, during Ship review to catch naming and function-size issues, and during refactor passes on legacy modules. It does not replace linters or formatters; it raises the bar for readability and change safety so the next you—or the next agent session—can modify code confidently.7.5kinstalls5Api Security Best PracticesAPI Security Best Practices is a community agent skill that walks solo builders through securing APIs end to end: pick an auth model, enforce RBAC and session hygiene, validate and sanitize every input, and layer rate limiting plus throttling before production traffic arrives. It is framed for REST, GraphQL, and WebSocket surfaces, so indie SaaS and agent-backend makers can apply one playbook instead of scattered blog posts. Invoke it when designing new routes, retrofitting legacy endpoints, or preparing for a security audit—not as a substitute for penetration testing, but to catch predictable OWASP-class mistakes early. The skill’s two-step structure (authZ/authN first, validation second) gives agents a clear review order for PRs and architecture docs. On Prism it sits under Ship security with strong ties to Build backend work where schemas and data access are defined.7.4kinstalls6Nextjs Best PracticesNext.js Best Practices is an agent skill that encodes App Router principles for solo and indie builders using Claude Code, Cursor, or Codex on React sites. It walks through when to default to Server Components versus marking interactive islands with use client, how to choose fetch caching for database reads, external APIs, and user-driven mutations via server actions, and how to organize pages with layouts, loading boundaries, and error surfaces. The guidance is procedural knowledge—not a scaffolder—so you invoke it while designing routes, refactoring a page that overuses client state, or aligning a small SaaS dashboard with performance-friendly data flow. It matters because misclassified components and cache modes are a common source of bundle bloat and stale data in one-person teams who cannot afford a dedicated frontend platform review.5.7kinstalls7Nextjs Supabase AuthNext.js + Supabase Auth is an agent skill for expert integration of Supabase authentication with the Next.js App Router. Solo builders shipping SaaS or API-backed products use it when sessions must work in both client components and server actions without leaking cookies or breaking refreshes. The skill documents how to create browser and server Supabase clients with proper cookie get/set hooks, and extends into middleware and callback handling for route protection and OAuth flows. It assumes you already understand App Router layout and Supabase projects via named prerequisite skills. Risk is listed as none at the metadata level, but you still must manage secrets and redirect URLs in production. The patterns favor the official SSR package rather than ad-hoc REST calls, which keeps auth state consistent as you add RLS-protected data access.5.2kinstalls8Browser AutomationBrowser automation is procedural guidance for solo builders and agents who need dependable control of real browsers—not one-off scripts that break on the next deploy. It compares Playwright and Puppeteer and argues Playwright is the default in 2025 unless Puppeteer’s stealth or Chrome-only constraints matter. The skill teaches selector strategy, waiting behavior, isolation, and observability so E2E suites and agent tools behave predictably on sites you own, while a separate mental model covers unpredictable targets where anti-detection and resilience matter. Principles emphasize user-facing locators, never adding manual waits when the framework auto-waits, fresh context per run, and screenshots plus traces when debugging. Use it when wiring CI browser tests, building agent browsers, or hardening scrapers before you commit to a stack.5.1kinstalls9Prisma ExpertPrisma Expert is an agent skill for solo builders who standardize on Prisma ORM for SaaS and API backends. It walks agents through version and provider detection, migration folder checks, and categorized fixes for schema design, relations, and Client queries on PostgreSQL, MySQL, and SQLite. The skill deliberately stops early when the problem is raw SQL optimization, database server configuration, or connection pooling at the infrastructure layer—pointing you to specialist skills instead of blurring scope. Use it during active backend work when migrations fail, relations are modeled wrong, or queries need Prisma-native remediation. Progressive fixes plus validate-with-CLI discipline reduce trial-and-error loops for one-person teams who cannot afford silent schema drift or broken `prisma generate` in CI.3.6kinstalls10Playwright SkillPlaywright-skill packages procedural knowledge for Microsoft Playwright so Claude Code, Cursor, Codex, and similar agents can automate Chromium, Firefox, and WebKit like a focused QA teammate. It is aimed at solo and indie builders shipping web SaaS, APIs with browser clients, or CLIs that still need smoke checks against a UI. Reach for it when you are adding or fixing end-to-end coverage, stabilizing flaky selectors and waits, wiring visual or a11y checks, or integrating browser tests into CI—not when you only need isolated unit tests with no browser. The bundled reference walks installation, locators, common actions, assertions, page objects, network and API testing, authentication, visual and mobile testing, debugging, parallelism, and troubleshooting in plain steps an agent can follow. That depth reduces wrong API guesses and inconsistent test structure across sprints.3.3kinstalls11Software ArchitectureSoftware Architecture is an agent skill that steers coding and design toward quality: Clean Architecture, DDD-informed boundaries, and pragmatic style rules. Solo and indie builders invoke it whenever an agent implements features, sketches system layout, or reviews diffs—not only greenfield backends. It pushes early returns, shorter files, reusable functions, and a library-first mindset (prefer maintained packages like retry libraries over hand-rolled utils). The skill spans analysis and implementation, so it fits ongoing iteration in Ship and Operate as well as initial Build work. Use it when you want consistent structure without a separate architecture doc for every small task.2.9kinstalls12Product Manager ToolkitProduct Manager Toolkit is an agent skill that bundles frameworks and small Python utilities for solo founders who must play product manager without a dedicated PM bench. It supports RICE-based feature scoring with reachable CSV workflows, interview transcript analysis, and PRD templates you fill after discovery conversations. The documented process walks from gathering requests—feedback, sales, tech debt, and strategy—through portfolio checks and capacity-aware quarterly roadmaps. For indie SaaS and agent-product builders, it turns scattered notes into ordered bets your coding agent can implement against. It complements generic brainstorming by adding quantitative prioritization and delivery-shaped documents, but it does not replace legal, finance, or deep market research suites—you still supply real reach, impact, and effort estimates.2.9kinstalls13Game DevelopmentGame-development is an orchestrator agent skill for solo and indie builders who are starting or restructuring a game project and need disciplined routing instead of one generic game prompt. It teaches shared principles first, then maps your context to specialized sub-skills for platform (web, mobile, PC, VR/AR), dimension (2D or 3D), and specialties such as design, multiplayer, art, and audio. Use it at the beginning of build work when stack choices are still open, and again when scope shifts—for example moving from a 2D web prototype to a mobile release. The skill does not replace engine-specific documentation in Unity, Godot, or Unreal; it tells your agent which focused skill to load next. That makes it especially valuable for one-person teams who wear design, code, and production hats and need a consistent entry ritual before deep implementation.2.7kinstalls14Mobile DesignMobile Design is an agent skill that gives solo builders structured decision trees for mobile product choices instead of defaulting to the framework they already know. It walks through what you are building—whether you need over-the-air updates without store review, branded pixel-perfect UI, deep native hardware APIs, or leverage from an existing TypeScript web team—and maps each branch to sensible stacks such as React Native with Expo, Flutter, SwiftUI, Jetpack Compose, or Kotlin Multiplatform. The documentation stresses these are thinking guides: the agent should reason through tradeoffs with you, not dump a single recommendation. State management and storage strategy sit alongside framework selection so early validate and prototype conversations cover persistence and client architecture, not just UI toolkit logos. Indie founders use it when scoping a first mobile app, debating cross-platform vs native, or aligning a small team’s skills with a shippable path before Build frontend work begins.2.7kinstalls15Telegram Bot Buildertelegram-bot-builder is a procedural skill for solo makers who want Telegram bots that feel like helpful assistants rather than clumsy command menus. It spans architecture choices, Telegram Bot API mechanics, conversation and command design, inline keyboards, webhook deployment, and libraries such as Node.js with Telegraf or Python stacks noted in the patterns section. The skill also pushes beyond pure coding into product thinking—user onboarding flows, analytics, monetization strategies, and scaling to large chat audiences—so indie builders treating a bot as a micro-SaaS get a single narrative inside their agent session. Webhook management and stack selection tables give agents concrete defaults instead of generic REST advice. Because messaging bots often bridge automation and growth, the skill is tagged multi-phase with secondary placement in Grow for lifecycle and monetization topics. Prism users searching for Telegram automation, community bots, or AI-backed chat interfaces should invoke this during initial implementation and when refactoring UX before marketing pushes.2.7kinstalls16Ui Ux Pro Maxui-ux-pro-max is a reference skill that packages a structured chart-and-visualization taxonomy for indie builders designing SaaS dashboards, marketing analytics, and in-app reporting. Instead of improvising pie charts for ten categories or scatter plots without density handling, you align each data story—trends, rankings, proportions, correlations, intensity grids—to a primary chart type, fallback options, palette rules, performance expectations, and accessibility tradeoffs. The material reads like a design-system appendix for data UI: when to prefer horizontal bars over pies, when heatmaps need tables as alternatives, and which JavaScript chart stacks fit hover-zoom versus brush interactions. Use it while scaffolding admin panels, growth metrics pages, or prototype validation charts so agents and humans share the same vocabulary. It does not replace brand design or user research; it accelerates consistent, defensible visualization choices during implementation and when revisiting analytics UX later in the journey.2.6kinstalls173d Web Experience3d-web-experience is an agent skill that acts as a 3D web experience architect for solo and indie builders adding depth to the browser. It centers on Three.js, React Three Fiber, Spline, WebGL, and GLSL shaders, with explicit guidance on when 3D genuinely improves the product versus when it only adds weight. The skill walks through stack selection at project start, implementation patterns for interactive scenes, workflows for preparing and integrating models, and optimization so frames stay smooth on mid-range devices. It is aimed at builders shipping configurators, immersive landing pages, or portfolio moments without a dedicated 3D team. Use it during frontend build when you need procedural expertise for R3F component structure, Spline handoff, shader tweaks, or performance budgets rather than generic React advice.2.4kinstalls18Bun Developmentbun-development is a community-sourced agent skill that teaches fast JavaScript and TypeScript development on the Bun runtime, aligned with oven-sh/bun capabilities solo builders want when Node feels slow or toolchain-heavy. Use it when starting a new CLI, API, or SaaS backend in TS, migrating an existing Node repo, or leaning on Bun’s integrated bundler and test runner instead of juggling separate tools. The skill opens with audited-style install commands—including curl installer inspection patterns and Windows PowerShell equivalents—then frames when Bun wins on developer velocity. It is aimed at indie developers comfortable in the terminal who want opinionated setup steps agents can execute, not abstract language trivia. Tagged multi-phase because test and bundler choices ripple into Ship workflows. Catalog risk is marked critical; treat install scripts and community origin as review items alongside Prism security panels.2.2kinstalls19Web Performance OptimizationWeb Performance Optimization is an agent skill that walks solo builders through measuring, diagnosing, and fixing slow websites and web apps. It starts with establishing baselines using Lighthouse, Core Web Vitals, bundle sizes, and network waterfalls, then categorizes common bottlenecks such as oversized JavaScript, unoptimized images, render-blocking assets, weak caching, slow server response, layout shift, and blocking long tasks on the main thread. The workflow is designed for founders shipping marketing sites, SaaS dashboards, or content products who need repeatable steps before a performance audit or when users complain about load time. It connects technical fixes to outcomes that matter for indie builders: better perceived speed, improved search signals tied to CWV, and higher conversion on landing pages. Use it when you are preparing for a formal audit or chasing specific metrics rather than doing ad-hoc tweaks in chat.2.2kinstalls20I18n Localizationi18n-localization packages a small Python i18n checker that helps solo builders find hardcoded copy before international rollout. It walks project files with regex tuned for React JSX, Vue templates, and Python (prints, raises, Flask flash) while noting when proper translation helpers appear. Use it when you are adding locales, prepping a launch in new markets, or cleaning tech debt after rapid UI iteration. It does not replace a full i18n library setup or translation management platform; it surfaces likely misses so you can wire keys into react-i18next, Vue i18n, or gettext workflows. Run it in CI or on demand from an agent before release branches merge. Pair with your existing locale files and translation coverage goals so fixes are prioritized by user-visible surfaces.2kinstalls21Nestjs ExpertNestJS Expert is a community framework skill that turns your coding agent into a senior Nest.js consultant for indie APIs and small SaaS backends. On invoke it expects you to stay in-domain: pure TypeScript typing, raw SQL optimization, Node runtime quirks, or React UI should hand off to named specialist skills rather than forcing Nest patterns where they do not belong. The workflow starts by detecting how your project modules, providers, and imports are already arranged, then applies idiomatic fixes for circular dependencies, guard and interceptor chains, authentication, and persistence integration. A explicit validation ladder—typecheck, then unit, integration, and e2e tests—keeps changes from shipping as compile-only patches. Solo builders use it when standing up feature modules, debugging provider scope conflicts, or aligning tests with Nest testing utilities. It is procedural architecture knowledge, not a hosted runtime; pair it with your ORM and deployment skills for end-to-end delivery.2kinstalls22Powershell WindowsPowerShell Windows is a reference skill for solo builders shipping on Windows—local dev, MSI-style tooling, or agent-generated setup scripts. It encodes the failures that waste afternoons: logical operators without parentheses around cmdlet calls, unicode in Write-Output that breaks encoding, and null dereferences on empty arrays. Agents invoke it when drafting or reviewing .ps1 files for build hooks, deployment helpers, or desktop-adjacent SaaS tooling. It is not a cmdlet encyclopedia; it is a pitfall checklist so generated scripts parse correctly and behave predictably in non-interactive runs. Pair it with your repo’s CI story on Windows runners when you move from laptop scripts to automated ship and operate tasks.1.9kinstalls23Security Reviewsecurity-review is a community agent skill that keeps implementation work aligned with application security basics. Solo builders shipping SaaS, APIs, or agent backends invoke it whenever they touch authentication, authorization, user-controlled input, file uploads, credentials, payment flows, sensitive data, or external APIs. The skill walks through explicit do-and-don’t patterns—especially around hardcoded secrets versus environment variables—and ties each area to verification steps you can tick off before merge or deploy. It is a procedural reviewer, not a dynamic scanner: your agent applies the checklist to the code you are writing or changing. Pair it with your normal ship workflow so security is part of feature work rather than a panic pass the night before launch.1.8kinstalls24Senior ArchitectSenior Architect is a community toolkit skill that wires three automated Python utilities into a repeatable architecture workflow for solo builders shipping SaaS, APIs, or CLIs. Before you lock stack choices or folder layout, you point Architecture Diagram Generator at a project path to scaffold diagram artifacts with template and quality guardrails. Project Architect performs deeper structural analysis with verbose metrics and remediation suggestions when you need evidence before refactoring. Dependency Analyzer surfaces coupling and integration risks with production-oriented configuration hooks. The skill is intermediate in practice: you run scripts from a terminal, pass paths and flags, and interpret generated outputs rather than chatting ad hoc about boxes and arrows. It fits Validate when narrowing scope, Build when evolving backend and integration boundaries, and Ship review when validating that the implemented graph still matches intent. Frontmatter labels the bundle critical risk—review scripts locally and avoid blind --fix style automation on production trees.1.7kinstalls25BrainstormingBrainstorming is a journey-wide agent skill that turns raw ideas into clear, validated designs and specifications through disciplined, one-question-at-a-time dialogue before any implementation begins. It is aimed at solo and indie builders using Claude Code, Cursor, Codex, or similar agents who tend to jump straight into code and later pay for hidden assumptions, misaligned solutions, and fragile systems. The skill forces a slow-down: review current project context first, clarify the idea without silent assumptions, and stay in facilitator mode—no speculative features and no skipping ahead. Use it whenever creative or constructive work is on the table (features, architecture, behavior) and a written or mental spec is not yet locked. The outcome is shared clarity and a design you can hand to planning or implementation skills without premature coding.1.7kinstalls26Api Documentation GeneratorAPI Documentation Generator is an agent skill for solo builders and small teams shipping HTTP or realtime APIs who need professional reference docs without hiring a technical writer. After you point the agent at your codebase, it follows a structured process: inventory endpoints and HTTP methods, map request parameters and response shapes, document authentication and authorization expectations, and capture error-handling patterns. It then produces endpoint-level pages with method, path, purpose, auth requirements, rate-limit notes where relevant, and copy-paste-friendly examples. The skill explicitly targets moments when documentation is missing, stale, or blocking onboarding—whether you are documenting a greenfield API, refreshing docs after a breaking change, or preparing materials for external integrators including OpenAPI/Swagger output. Complexity is intermediate because you still need a coherent API surface in code for analysis to be accurate. It pairs naturally with code review and ship-time checks when you want docs to match what actually ships.1.7kinstalls27Ui Ux Designerui-ux-designer is an agent skill that acts as a UI/UX expert for solo and indie builders who need structured interface work without hiring a full design team. It covers user-centered design, modern design systems, and accessible interface creation—from clarifying goals and constraints through actionable verification steps. The skill emphasizes atomic design, token-based architecture, component libraries, cross-platform consistency, and design-system governance. Invoke it when you are defining wireframes, evolving a design system, or need checklists and best practices for professional UX delivery. It points to a detailed implementation playbook for deeper examples. It fits naturally while you prototype in Validate and while you build frontend surfaces, but the heaviest artifact types live in the Build phase.1.6kinstalls28Frontend Designfrontend-design is an agent skill aimed at solo and indie builders who want memorable, high-quality interfaces while coding with AI assistants. It sits in the Build phase on the frontend shelf because its job is to shape how screens, components, and visual language come together before you ship. Install it when you are turning a validated idea into something users actually see and touch, and you need the agent to avoid bland, interchangeable UI defaults. The skill typically pushes toward clear typography, deliberate color and motion choices, and layouts that feel intentional for SaaS, content, or lightweight mobile web experiences. It is a procedural design companion—not a Figma replacement—meant to be invoked during implementation passes, refactors, and polish cycles. Use it alongside your stack-specific framework skills so visual decisions stay consistent as the codebase grows.1.6kinstalls29Agent Memory SystemsAgent Memory Systems is an agent skill that teaches solo builders how to architect memory for coding agents and custom assistants: short-term context windows, long-term vector stores, and cognitive organization using the CoALA framework (semantic facts, episodic experiences, procedural how-to). It stresses that storage volume matters less than retrieval—chunking, embeddings, and strategy determine whether prior sessions actually help the next task. Principles include matching memory type to information, decaying stale entries, isolating context as an enemy of recall, and validating retrieval before production. The skill is methodology and architecture guidance rather than a single vendor integration, so it applies when you are designing RAG pipelines, session summarization, or persistent user profiles for Claude Code-style workflows. Use it early when agents feel amnesiac across chats or when every prompt re-explains the same repo facts.1.5kinstalls30Senior FullstackSenior-fullstack is a broad reference skill aimed at solo builders who want agent answers grounded in senior-level full-stack habits rather than one-off snippets. It organizes material into reusable architecture patterns, each with description, when-to-use scenarios, example TypeScript, benefits, and trade-offs. Supporting guidelines cover how to structure codebases, think about performance bottlenecks, and apply baseline security controls from input validation through authorization. Anti-pattern callouts and tool lists give you quick guardrails when you are sketching a new service, reviewing an agent-generated module, or preparing to scale traffic. The bundled readme is template-shaped, so treat it as a checklist scaffold you extend with your stack specifics rather than a turnkey framework install.1.5kinstalls31Database DesignDatabase Design is a procedural agent skill that helps solo and indie builders choose a datastore and shape indexes from requirements—not habit. It opens with a 2025-oriented selection tree that branches on full relational needs, edge latency, embedded simplicity, AI vector search, and global distribution, then compares Postgres, Neon, Turso, SQLite, and PlanetScale on trade-offs. A short questionnaire forces clarity on deployment, query complexity, serverless/edge priorities, vector needs, and multi-region goals before you commit. The indexing section explains when to index filter, join, sort, and foreign-key columns and when not to on write-heavy or low-cardinality fields, plus index type selection starting with B-tree defaults. Use it when scaffolding a new service, revisiting a prototype that outgrew SQLite, or planning performance before migrations. It complements ORM setup skills by framing durable data architecture decisions your agent can cite in ADRs and migration plans.1.5kinstalls32Shopify DevelopmentShopify Development is an agent skill package for solo and indie builders who need to ship on Shopify without guessing OAuth flows, extension surfaces, or Admin API shapes. It organizes guidance into app development, UI extensions, theme Liquid architecture, and Shopify Functions for discounts, payments, and delivery rules. The skill emphasizes Shopify CLI workflows, Polaris for extension UIs, and operational concerns such as webhooks and billing integration. A practical differentiator is schema-checked GraphQL aligned to Admin API 2026-01, reducing agent hallucinations on mutations and field names. Interactive scaffolding via shopify_init.py and GraphQL helpers lower the friction of starting a new app or extension repo. Use it when conversation turns toward merchant apps, checkout customization, POS add-ons, or theme sections—not for generic React storefronts off-platform. After core build, you still handle Shopify Partners review, scopes, and deployment separately in Ship and Launch.1.4kinstalls33Vercel DeploymentVercel Deployment is procedural knowledge for solo and indie builders shipping Next.js on Vercel. It walks through the three Vercel environments—local development, preview branches on pull requests, and production on main—and how to split public browser variables from private server keys so service roles never leak via NEXT_PUBLIC_ prefixes. The skill explains when to pick edge versus serverless runtimes for API routes and middleware, tying cold-start and API surface constraints to concrete route configuration choices. It expects familiarity with App Router patterns from the nextjs-app-router prerequisite skill. Use it while wiring Supabase or database URLs, staging versus production keys, and preview deployments before you call a launch done. It complements generic CI docs by focusing on Vercel dashboard settings and in-code environment detection rather than abstract hosting theory.1.4kinstalls34Youtube Summarizeryoutube-summarizer is an agent skill that accepts YouTube URLs, validates that transcripts are obtainable, and generates detailed written summaries from extracted text. It leans on the youtube-transcript-api Python package and a STAR plus R-I-S-E analysis framework so outputs read like reference documentation rather than tweet-length blurbs. Solo builders use it during research sprints—competitive teardowns, framework tutorials, conference talks—when pausing video to take notes is too slow. The skill explicitly favors verbose capture of arguments, insights, and key points for later citation in specs, newsletters, or learning logs. Invoke it when users ask to summarize, resume, or extract content from YouTube; avoid when you need official API licensing workflows or non-YouTube sources.1.4kinstalls35Bash LinuxBash Linux is a journey-wide reference skill that encodes essential Bash and Unix terminal patterns for indie builders working on macOS or Linux. Agents load it whenever shell work risks turning into fragile copy-paste: installing dependencies, grepping logs, freeing ports, chaining build steps with &&, or scripting small automation without re-deriving syntax each time. The readme organizes guidance into operators, file operations, process management, and text processing tables so answers stay copy-paste accurate rather than hallucinated flags. It does not replace full shell scripting courses; it keeps day-one commands consistent across Claude Code, Cursor, and Codex sessions. On Prism it sits with CLI tooling because procedural terminal knowledge improves every phase—from Validate prototypes through Operate incident triage—even though the canonical shelf is Build.1.3kinstalls36App Store Optimizationapp-store-optimization is an agent skill packaging Python-oriented App Store Optimization logic focused on A/B test design for listing assets. It helps solo mobile founders specify control and variant metadata, state hypotheses, and align success metrics with conservative minimum effect sizes per asset type. The module fits Launch phase work after TestFlight or Play internal testing, when small conversion lifts on icons or screenshots materially change installs. Builders invoke it when planning structured experiments instead of swapping store creatives ad hoc. It complements broader ASO copy skills by emphasizing statistical confidence and test_type discipline for icons through descriptions.1.3kinstalls37Scroll Experiencescroll-experience is an agent skill that teaches how to architect immersive, scroll-controlled web narratives—parallax layers, reveal sequences, sticky chapters, and progress cues—using stacks like GSAP ScrollTrigger and Framer Motion. Solo builders shipping marketing sites, product launches, or portfolio pieces install it when flat pages fail to convey story or premium positioning. The skill frames scrolling as a narrative device with explicit patterns for when to stay subtle versus cinematic, plus capability lists for scroll-triggered reveals and interactive flows. It fits the Build phase but also supports Validate prototypes and Launch distribution pages that must feel editorial rather than template-driven. Intermediate front-end comfort with animation libraries and layout performance is expected; it is not a copywriting or analytics toolkit.1.2kinstalls38Bullmq SpecialistBullMQ Specialist is an agent skill for solo and indie builders shipping Node.js or TypeScript services that cannot afford to lose or duplicate background work. It encodes how to treat jobs as fire-and-forget on the producer side while you own idempotency, backoff, and dead-letter paths on the consumer side. The skill maps concrete capabilities—scheduling, delayed and repeatable jobs, priorities, rate limits, events, workers, flows, and dependencies—so your agent does not hand-wave queue semantics. It also steers you away from the wrong tool: Redis plumbing, pure serverless fan-out, long-running orchestration, event-sourced pipelines, and transactional email each belong to named alternatives in Scope. Use it when you are adding or hardening async workloads (webhooks, emails, reports, AI batch jobs) and need opinionated defaults instead of BullMQ’s generic out-of-the-box behavior. Pair it with a Redis hosting choice and monitoring before you scale concurrency into downstream APIs.1.2kinstalls39Backend Dev Guidelinesbackend-dev-guidelines positions your coding agent as a senior backend engineer building Node.js, Express, and TypeScript services under production constraints. Solo builders and small teams use it when implementing or refactoring APIs, service layers, repository code, and Prisma data paths so structure stays predictable and failures stay bounded. The skill opens with the Backend Feasibility & Risk Index (BFRI), asking you to score architectural fit, domain complexity, and data risk before coding. It then encodes layered architecture, validation, centralized configuration, and observability as non-negotiable requirements rather than tips. That makes it especially valuable when agents otherwise generate sprawling route handlers or skip repository boundaries. It does not replace infrastructure provisioning or security pentests; it standardizes how application backend code must be written once you are in the Build phase.1.2kinstalls40Prompt EngineerPrompt-engineer is a community automation skill that rewrites raw user intent into high-quality prompts using established structuring frameworks. Solo builders hitting weak results from generic instructions—help me code Python, debug this, write a landing page—invoke it to add role, constraints, steps, and output shape matched to task complexity. It analyzes intent, picks one or more frameworks from a broad catalog spanning reasoning chains and structured narratives, and returns a prompt you can paste into Claude Code, Codex, or Cursor. Magic mode keeps the mechanics invisible unless a missing detail would break the task. Because prompting quality affects every phase, treat it as journey-wide hygiene: use before creative work, complex analysis, or any agent session where clarity beats improvisation. Risk is marked safe; category automation maps to agent-building practice for the Prism catalog.1.2kinstalls41Documentation TemplatesDocumentation Templates gives solo builders a shared scaffolding for READMEs, API references, and code comments so agents stop generating inconsistent markdown on every session. The skill orders README sections for scanability—quick start before deep configuration—and supplies a repeatable per-endpoint API outline with parameter tables and example blocks. It also nudges toward JSDoc/TSDoc patterns that help both humans and coding agents reason about types and behavior. You will reach for it during Build while the repo is still taking shape, but the same templates pay off at Ship when reviewers expect clear setup steps and at Launch when external readers discover your project. Beginners benefit immediately because the tables spell out what belongs in each section without demanding a separate docs platform.1.2kinstalls42FirebaseFirebase is an agent skill that helps solo and indie builders use Google Firebase as a full backend—authentication, Firestore or Realtime Database, Cloud Functions, Cloud Storage, and Hosting—without treating the quick setup as proof the architecture is safe or cheap. The skill argues for designing documents and collections around the queries and listeners you will actually run, denormalizing aggressively, and writing security rules before clients touch production data. It explains why relational mental models break on Firestore, when to batch writes and use transactions, how offline persistence affects cost and complexity, and which work belongs in Cloud Functions instead of the client. Invoke it while you are scaffolding or refactoring a Firebase backend, tightening rules ahead of launch, or debugging surprise read bills from poorly scoped listeners. It is written for builders shipping with Claude Code, Cursor, Codex, or similar agents who need procedural Firebase knowledge rather than a one-off snippet for a single API call.1.2kinstalls43Conversation MemoryConversation Memory is an agent skill that teaches solo builders how to layer short-term, long-term, and entity-based memory for LLM-powered apps. It walks through a tiered MemorySystem interface—conversation buffer in context, session-scoped recall, durable user facts, and named entities—so assistants stop re-asking the same questions every session. The skill stays on memory patterns for agents: what to store, when to consolidate, and how to retrieve without replacing a full knowledge graph or semantic search stack. It is aimed at indie developers shipping chat products, copilots, or internal agents who already understand basic databases or key-value stores and want a practical blueprint before wiring Mem0, LangChain memory utilities, or Redis-backed session state. Use it during Build when agent behavior must feel continuous, and revisit during Operate when you tune retention, privacy, and cost of stored memories.1.2kinstalls44Copywritingcopywriting is a disciplined marketing copy skill for solo builders who need landing pages and lifecycle emails that convert without crossing ethical lines. It forces a structured briefing—page type, single primary action, audience pain, tried alternatives, objections, and real product differentiators—before the agent drafts headlines, body copy, or CTAs. The operating mode rejects vague hype and invented social proof, favoring honest outcome language you can A/B test on a waitlist, pricing page, or launch sequence. Use it when you are validating demand with a landing page, refreshing positioning before ship, or drafting launch emails where credibility matters more than clever wordplay. It does not replace SEO technical work or visual design; pair it with analytics after Grow once pages are live.1.2kinstalls45Github Workflow AutomationGitHub Workflow Automation is an agent skill that packages patterns for automating GitHub with AI-assisted steps—PR reviews, issue triage, Actions workflows, CI/CD hooks, and selected git operations. Solo builders shipping from a single repo use it when manual review bottlenecks or repetitive triage slow Ship-phase delivery. The skill walks through concrete workflow YAML such as fetching diffs against the base branch, scoping permissions for contents and pull-requests, and wiring review jobs on pull_request events. It fits developers who already host on GitHub and want repeatable automation rather than one-off chat-generated pipelines. Because it touches tokens, branch protection, and production deploy paths, treat outputs as drafts you harden with org policies. Pair it with your existing test and security checks so AI review augments rather than replaces human judgment on critical-risk changes flagged in the skill metadata.1.1kinstalls46Backend ArchitectBackend Architect is a multi-phase agent skill that acts as an architecture partner for indie builders about to grow beyond a single route file. It walks you from domain context and non-functional requirements through service boundaries, API contracts, integration choices, resilience patterns, and an observability-aware rollout plan. Use it when scoping a new API or replatforming toward microservices—not when you only need a localized bug fix or UX polish. The skill emphasizes clear boundaries and contracts so Claude Code or similar agents do not sprawl dependencies across your repo. It sits primarily on validate/scope but informs build/backend integrations and operate/monitoring decisions once traffic is real.1.1kinstalls47Aws ServerlessAWS Serverless is an agent skill that packages production-oriented patterns for solo and indie builders shipping on Lambda. It walks through right-sizing memory and timeouts, minimizing cold starts, choosing HTTP API Gateway where REST is overkill, and wiring DynamoDB plus SQS/SNS for event-driven flows. Expect concrete handler structure in Node.js (and the same reuse-outside-handler discipline transfers to other runtimes), structured logging with correlation IDs, DLQs and retries, and keeping artifacts lean for faster cold paths. SAM and CDK appear as the default deployment story so you can go from handler code to a repeatable stack without ad-hoc console clicking. Use it when you are implementing APIs, schedulers, or stream consumers—not when you only need a generic AWS account tour. Pair with testing and security skills before you flip traffic in production.1.1kinstalls48Gcp Cloud RunGCP Cloud Run is a specialized agent skill for solo builders and small teams deploying serverless workloads on Google Cloud. It walks through when to choose Cloud Run services versus Functions, how to structure Dockerfiles for lean images, and operational defaults that affect latency and cost such as concurrency, memory, minimum instances, and optional VPC connectors. The material emphasizes stateless containers, graceful shutdown on signals, and event-driven designs with Pub/Sub—patterns typical of indie SaaS APIs and background workers without running a full Kubernetes cluster. Use it while implementing or refactoring a GCP backend; pair it with your repo’s deploy scripts and observability stack for Operate-phase tuning. It does not replace official GCP console setup for billing, IAM, or org policies—you still own those decisions before shipping traffic.1.1kinstalls49Cc Skill Security Reviewcc-skill-security-review is a procedural agent skill that walks solo builders through security best practices while they implement sensitive features. It is meant when you add authentication or authorization, accept user input or uploads, stand up API endpoints, handle credentials, build payment flows, or move sensitive data. The skill contrasts unsafe patterns (hardcoded keys and passwords) with environment-based configuration and explicit failure when secrets are missing. It pairs narrative guidance with a Security Checklist you can tick through: secrets management verification, input validation discipline, and related controls called out in the SKILL body. For indie SaaS and API products shipping on Vercel, Railway, or similar hosts, it acts as a repeatable pre-merge guardrail so agents do not bake exploitable defaults into TypeScript or backend code. Use it during active implementation and again before release when the attack surface changed.1.1kinstalls50Browser Extension BuilderBrowser Extension Builder is an agent skill for solo makers who want a real Chrome or Firefox extension—not a weekend hack that dies in review. It frames you as a browser extension architect: permissions, security boundaries, Manifest V3 service workers, content scripts, and popup experiences that users open daily. The skill covers capability checklists from architecture through Chrome Web Store publishing and touches cross-browser portability and monetization thinking appropriate for one-person shops. Use it when you are starting a new extension repo, migrating toward MV3, or hardening UX and policy compliance before submission. It emphasizes the gap between demo extensions and dependable tools—clear structure, API usage, and store-ready packaging. It does not replace reading current store policies or manual QA in target browsers; it accelerates decisions and file layout so you spend less time guessing extension-specific patterns.1.1kinstalls51Discord Bot Architectdiscord-bot-architect is a specialized build skill for solo creators who want community agents, moderation tools, or product notifications inside Discord without tripping gateway limits or deprecated message parsing. It encodes opinionated production habits: slash commands instead of Message Content Intent, fast interaction acknowledgements, least-privilege intents, graceful 429 handling, and sharding foresight once guild count scales. Patterns span a Discord.js v14 foundation with event and command loading structure and parallel guidance for Python via Pycord. You get concrete setup for collections, environment config, and component-driven flows so bots feel native rather than spammy. Use it when you are shipping a bot as part of your growth loop, a support concierge, or a devrel presence—especially if you expect interactions beyond simple text replies.1.1kinstalls52React Ui Patternsreact-ui-patterns is a community agent skill that teaches modern React handling for async UI: when to show spinners versus cached data, how to surface errors with retry, empty states, and optimistic updates so SaaS dashboards feel fast. Solo builders shipping with Cursor or Claude Code often lose hours on flickering loaders and silent failures; this skill compresses opinionated patterns into copy-paste decision trees and CORRECT versus WRONG examples tied to typical data-fetch hooks. It is not a component library—it is procedural guidance for states every list, form, and detail view needs. Use while implementing features in the build phase and again during ship review when polishing perceived performance. Intermediate familiarity with React and client data fetching is assumed. The skill aligns with agentic workflows where the model refactors existing screens rather than greenfield design systems.1.1kinstalls53Systematic DebuggingSystematic debugging is an agent skill that steers you through structured failure analysis rather than reactive edits. It is aimed at solo and indie builders who ship with Claude Code, Cursor, or Codex and keep hitting intermittent test failures, timing races, or unclear stack traces. Use it when a bug reproduces inconsistently, when CI is red for flaky reasons, or when you are tempted to add another sleep() instead of understanding ordering. The skill’s embodied techniques—event-type waits, bounded timeouts with clear errors, and incremental verification—mirror how mature teams debug distributed and agentic workflows. It is not a linter or a single API wrapper; it is procedural knowledge for narrowing hypotheses, confirming fixes, and avoiding regression. Pair it with your existing test suite and thread or async instrumentation so each iteration produces evidence, not hope.1.1kinstalls54Workflow Automationworkflow-automation is an agent skill for solo builders and tiny teams who script revenue, fulfillment, or agent pipelines and cannot afford a half-finished run after a timeout. It explains why durable execution matters—resuming mid-flow instead of double-charging or losing onboarding state—and maps how mainstream orchestration platforms differ so you pick on fit rather than hype. Principles emphasize event triggers, independently retryable steps, starting simple, and visibility into failures. Capabilities span orchestration vocabulary from the sickn33/Antigravity lineage (Apache 2.0 sourced). Use it while modeling a ten-step payment or provisioning chain, choosing between visual n8n graphs and code-first Temporal or Inngest workers, or pairing long-running workflows with AI agents that need checkpoints. It complements one-off cron scripts by focusing on production-grade patterns; you still bring your own secrets handling, idempotency keys, and compliance review for regulated flows.1.1kinstalls55Frontend Dev GuidelinesFrontend-dev-guidelines is a convention layer for solo builders shipping React admin or SaaS UIs that standardize on Material UI and in-house hooks. Rather than teaching framework basics, it tells agents how auth, forms, tables, and modals should look in this codebase: always route authentication through useAuth, pair React Hook Form with Zod schemas, and surface outcomes with the shared snackbar helper. That reduces drift when you iterate fast with Claude or Cursor across many screens. Invoke it during active feature builds and again at ship/review when you want the agent to refactor rogue fetch-based auth or ad-hoc form state into the house style. It assumes an existing design system and hook library rather than greenfield styling from scratch.1kinstalls56Ai Agents ArchitectAI Agents Architect is an agent skill for solo builders who want production-minded autonomous systems instead of one-off chat prompts. It frames the architect role around tool use, memory, planning, multi-agent orchestration, evaluation, and recovery—stressing that agents fail in surprising ways and need graceful degradation plus clear escalation to humans. Principles like fail loudly, crisp tool docs, and memory as context rather than crutch help indie developers avoid fragile demos that break silently in Ship and Operate. The skill is methodology-heavy rather than tied to a single framework, so it pairs well with whichever runtime you use in Claude Code, Cursor, or Codex. Use it when you are shaping agent boundaries before writing large skill libraries or wiring many tools, especially if you are tempted to add multi-agent complexity without a cost-benefit story.1kinstalls57Tailwind Design SystemTailwind Design System is an agent skill that walks solo and indie builders through implementing a production-ready UI foundation with Tailwind CSS. It is meant for the Build phase when you are creating or extending a component library, wiring design tokens into tailwind.config and CSS variables, and keeping patterns consistent as the codebase grows. The playbook explains token hierarchy from abstract brand values through semantic roles to component-specific usage, plus how to layer variants, sizes, and states on shared bases. It addresses responsive layouts, class-based dark mode, and accessibility expectations so agents do not ship one-off utility soup. Use it when you are standardizing buttons, forms, and surfaces, migrating to Tailwind, or theming a SaaS or marketing site. It is guidance and patterns—not a hosted design tool—so you still own repo structure and review generated config and components before merge.1kinstalls58Context Window ManagementContext-window-management teaches solo builders how to keep agent products usable as conversations grow: count tokens, trim noise, summarize history, and route turns to appropriately sized models. Sourced from vibeship-spawner-skills, it sits in the agent layer between prompt design and infrastructure—helpful when you are shipping multi-step copilots, support bots, or coding agents that accumulate tool transcripts. The SKILL.md defines capabilities and boundaries clearly: it optimizes context, it does not replace embedding pipelines or fine-tuning. Patterns like tiered ContextTier tables give concrete thresholds so you can implement policies in Claude Code or Cursor-backed services without guessing when to switch from full context to summarization. Intermediate complexity assumes you already tokenize prompts and understand why context rot hurts quality. Use alongside prompt-engineering when agents start dropping instructions or repeating stale facts mid-session.1kinstalls59Prompt EngineeringPrompt Engineering Patterns is a journey-wide agent skill that catalogs advanced prompting techniques—few-shot exemplars, chain-of-thought, and related reliability patterns—so solo builders get predictable outputs from Claude, Cursor, Codex, and similar stacks. Install it when a copilot wanders off-format, your support-ticket extractor returns JSON garbage, or you need to teach an agent a repeatable reasoning trace before you trust it on billing or deployment steps. The skill frames tradeoffs honestly: more examples improve accuracy but burn tokens, and verbose reasoning helps verification on hard logic. It fits anywhere you still depend on natural-language instructions—from Validate prototypes that need structured outputs, through Build agent-tooling, to Grow content pipelines and Operate runbooks that must not hallucinate steps. It does not replace eval harnesses or product specs; pair it with clear acceptance criteria and tests after prompts stabilize.993installs60ArchitectureArchitecture is a journey-wide agent skill that blocks generic stack recommendations until the agent interviews you about scale, team shape, timeline, domain complexity, and constraints. It is built for solo and indie builders who otherwise get microservice diagrams for a weekend MVP or monolith advice for a regulated multi-tenant SaaS. The playbook includes a classification matrix from sub-thousand-user prototypes through enterprise-scale systems, tying user counts, data volume, and transaction rates to appropriate pattern depth—from minimal Next.js-style setups to modular NestJS-style services and fuller distributed designs. After context discovery, it surfaces example decision records (such as solo e-commerce MVPs) so recommendations stay proportional. Use whenever you are about to commit to structure, not only at first validate pass; re-run when scale or compliance assumptions change.992installs61Agent Memory McpAgent Memory MCP is a community skill that equips solo builders running Claude Code, Cursor, or similar agents with a persistent, searchable knowledge layer backed by the webzler agentMemory project. Instead of re-explaining architecture and past decisions every chat, you install the skill into your workspace, compile the MCP server, and start it with a stable project identifier plus the absolute path to the repo you are shipping. The server exposes memory_search for filtering by query, memory type, or tags—useful when you need every authentication pattern or ADR on demand—and memory_write for recording new keys with typed metadata. That combination makes it a practical bridge between ephemeral agent threads and durable project memory, especially on multi-week builds where integrations and folder conventions accrue faster than human notes. Placement on Build → agent-tooling reflects the install-and-run workflow, but the same memory bank pays off during Operate when you iterate on production issues and during Grow when you reuse content patterns. It is an integration-style skill package, not a hosted Prism marketplace listing, so you own Node dependencies and the clone location unde991installs62Api Patternsapi-patterns is a concise reference skill for solo builders who must pick an API style and authentication approach without weeks of architecture debate. It walks through a consumer-first decision tree—public multi-platform clients favor REST with OpenAPI, complex multi-frontend data graphs favor GraphQL, TypeScript monorepos favor tRPC, real-time flows favor WebSocket with AsyncAPI, and internal microservices choose between gRPC and REST. A comparison table highlights tradeoffs like native HTTP caching versus client-side caching and manual OpenAPI typing versus end-to-end tRPC safety. A second section maps JWT, sessions, OAuth, API keys, and passkeys to typical integration shapes. Use it during Validate when you scope how third parties will integrate, and again in Build before you scaffold routes, OpenAPI, or tRPC routers so your agent does not default to whatever stack it saw last week.987installs63Interactive PortfolioInteractive Portfolio is an agent skill for solo builders who need more than a resume PDF: it treats the portfolio as a conversion surface where hiring managers and clients decide in seconds whether to reach out. It covers architecture, project showcases, interactive case studies, branding for technical and creative roles, testimonial placement, and performance so the experience stays fast and credible. Use it when you are restructuring an old portfolio, launching a freelance presence, or preparing for a job search while you already have work to show. The skill balances memorable creative coding with usable UX so you stand out without undermining trust. It aligns with Prism’s journey framing by supporting Validate (proof and scope storytelling), Launch (distribution and first impressions), and Grow (ongoing personal brand), even though the primary catalog shelf is Launch distribution.974installs64Tailwind PatternsTailwind Patterns is a reference skill for solo builders standardizing on Tailwind CSS v4 in 2025-style stacks. It explains the architectural shift from JavaScript tailwind.config.js to @theme blocks in CSS, the Oxide compiler’s speed profile, and how design tokens surface as --* variables for theming and dark mode. The content walks through semantic color naming with oklch, spacing scales, typography tokens, container queries, and native CSS nesting without extra PostCSS glue. It is for developers who want consistent utility-first UI without fighting deprecated patterns—especially when migrating from v3 or starting a new SaaS dashboard, marketing site, or browser extension popup. Use it while scaffolding or refactoring styles so agents do not reintroduce v3-only config files or heavy @apply layers. It does not replace a full component library; it gives opinionated patterns so Claude Code, Cursor, or Codex generate v4-correct CSS-first configuration and modern layout utilities aligned with your token architecture.968installs65Office ProductivityOffice Productivity is a workflow bundle that coordinates agent skills for LibreOffice Writer and Calc, Microsoft Word and Excel, PDF handling, and Google Sheets automation. Solo builders and tiny teams use it when they need programmatic documents, automated spreadsheets, presentations built from data, and reliable format conversion instead of one-off chat instructions. The SKILL.md lays out phased actions—template design, structure, programmatic content, formatting, and export—so an agent can chain the right official skills for each artifact type. It fits builders shipping client reports, investor decks, internal runbooks, or compliance packets while staying inside familiar office formats. Invoke it during Build when documentation and data-backed files are deliverables, and again in Grow or Validate when the same pipeline produces landing copy exports, pricing tables, or validation memos.967installs66Multi Agent BrainstormingMulti-Agent Brainstorming is a journey-wide agent methodology that simulates formal peer review for technical and product designs. One Primary Designer agent owns the proposal—typically by running the standard brainstorming skill and curating a Decision Log—while specialized reviewer agents critique within strict scope limits. The workflow is intentionally sequential and gated: creativity stays centralized, critique is distributed, objections must be addressed or explicitly deferred, and the run ends when decisions are logged rather than when ideation exhausts tokens. It targets solo builders who want multiple perspectives without chaotic multi-agent chatter, especially when failure modes, security posture, or scaling assumptions need adversarial scrutiny. Use it whenever you are about to commit to an architecture, API shape, or feature slice and want review-validated confidence across idea, validate, and pre-build planning moments—not as a replacement for lightweight tweaks with an already-approved spec.966installs67Test Driven DevelopmentTest-Driven Development is a procedural agent skill that makes your coding agent write tests before any production code, watch them fail for the right reason, then add the smallest change to go green and refactor safely. It targets solo and indie builders who ship with Claude Code, Cursor, or Codex and want regressions caught at the source instead of after a messy diff. Invoke it whenever you implement a feature, fix a bug, change behavior, or refactor—SKILL.md treats skipping as rationalization, not a shortcut. The skill encodes delete-and-restart discipline when code was written ahead of tests, which keeps agents honest about what is actually under test. It pairs naturally with code review and CI habits in the Ship phase while you are still typing in Build. Outcome is behavior locked by executable specs and a clear audit trail of what failed and why before merge.959installs68Code Review ChecklistCode Review Checklist is an agent skill that walks solo builders and small teams through a repeatable review workflow instead of ad-hoc comments in chat. It begins by anchoring on intent—what changed, why, and how it will be tested—then layers structured passes for whether the code solves the problem, whether edge cases and errors are handled, and whether the implementation stays readable and well factored. The skill aligns with serious Ship-phase habits: catching regressions before merge, surfacing security and performance risks early, and keeping reviews consistent when you are the only reviewer or training a contractor. Use it when you open a pull request, run a focused audit on a module, or need documentation that defines what “done” means for review on your repo. It complements linters and CI by adding human judgment gates that agents can still follow procedurally.951installs69Audio TranscriberAudio Transcriber is a productivity agent skill that ingests audio, runs local Whisper transcription, and optionally transforms the text through Claude or GitHub Copilot using prompts that can be refined by the prompt-engineer skill. When you supply a prompt, the workflow can show original versus improved versions and ask once whether to use the improved variant; when you omit a prompt, it suggests a document type, builds a structured prompt framework, and falls back to a default meeting prompt if you decline. Progress feedback uses tqdm and rich so long runs feel observable in the terminal. Solo builders use it to capture customer calls, founder syncs, and voice memos into PM-ready notes without a separate transcription SaaS. It spans Build for specs and meeting records, Grow for repurposed content, and Validate when you are synthesizing discovery interviews—always as an offline-friendly pipeline rather than a hosted API integration.946installs70Telegram Mini AppTelegram Mini App is an agent skill for solo builders who want to reach users inside Telegram rather than fighting mobile install friction. It positions you as a Mini App architect: you work with the Telegram Web App API, TON ecosystem tooling, TON Connect, payments, and authentication that Telegram exposes, while respecting in-app navigation and viral loops instead of desktop-web assumptions. The skill covers basic HTML structure for TWAs, integration hooks, monetization via crypto payments, and patterns for utilities, games, DeFi, and social experiences. It suits indies who already have a web stack and need Telegram-specific wiring, or who are validating a lightweight product embedded in a chat surface. Use it when you are actively building or extending a Mini App, not when you only need a marketing landing page outside Telegram.944installs71Python PatternsPython Patterns is a community agent skill that coaches solo builders through Python architecture choices instead of dumping fixed templates. Use it when you need to pick between FastAPI for APIs and microservices, Django for full-stack or CMS-style apps, Flask for minimal scripts, or Celery-backed workers—and when you must justify async patterns, type hints, and folder structure for the actual product you are shipping. The SKILL.md stresses interviewing the user when preferences are unclear and matching sync versus async to workload, which keeps agents from repeating the same stack every session. It fits Claude Code, Cursor, and Codex sessions where you are standing up backends, refactoring services, or revisiting structure before scale. After running it, you should have a reasoned stack and layout you can implement in your repo rather than orphaned example files.938installs72Bash ScriptingBash Scripting Workflow is a granular bundle skill that walks solo builders through designing and shipping shell automation the way a senior SRE would—not a single pasted script. Phase one locks purpose, I/O, error handling, and logging requirements via bash-pro. Phase two adds shebang, strict mode, getopts-style parsing, traps, and cleanup using bash-defensive-patterns. Phase three completes core implementation with the same invoked skills. It fits indie operators who deploy from a laptop, maintain cron backups, or glue CI steps without adopting a heavier language. The skill is methodology-plus-handoff: it names companion skills rather than inlining every pattern, so agents chain expertise instead of improvising fragile bash. Expect intermediate complexity because strict mode and trap semantics need discipline. Use when the deliverable is a maintainable .sh file, not a one-liner in chat.935installs73Context CompressionContext Compression Strategies is an agent skill for solo builders and small teams running extended coding-agent sessions that outgrow the context window or sit on top of enormous repositories. It explains when aggressive summarization backfires—lost file pointers and repeated re-fetch costs—and how to optimize total tokens per task instead of per request. The skill walks through anchored iterative summarization with persistent structured sections, compares opaque versus structured compression patterns, and gives activation triggers from SKILL.md: sessions hitting limits, five-million-token-scale codebases, custom summarization design, and compression QA frameworks. Use it before you standardize how your agent checkpoints conversation history, especially if you have seen forgotten edits or spiraling re-reads after truncation.930installs74Micro Saas LauncherMicro-SaaS Launcher is an agent skill for solo and indie builders who want a single playbook to go from niche idea to paying users without venture-scale scope creep. It casts the agent as a launch architect: validate demand with structured questions, cut an MVP that proves value, choose pricing that matches willingness to pay, and execute distribution moves that indie communities actually use. Coverage spans validation tables, MVP boundaries, metrics that matter at small MRR, and growth habits that compound when you are one person operating support and product. The tone rejects unicorn hunting in favor of profitable, focused software you can ship in weeks. Use it when you are deciding whether an idea deserves a build, when you need a launch checklist before Product Hunt or Twitter, or when you must align pricing and positioning before writing billing code. It pairs naturally with landing and scope skills earlier and with analytics skills once customers arrive.927installs75Inngestinngest is an integration-focused agent skill for solo builders who want serverless-friendly background jobs without running queue infrastructure. It teaches Inngest’s event primitive, step-based checkpoints, real sleeps, automatic retries with policy control, concurrency guards, idempotency keys, and fan-out from a single event. Functions are modeled as HTTP handlers, which fits Next.js, Express, Hono, Remix, and SvelteKit deploy targets including Vercel and Cloudflare Workers. The skill deliberately defers Redis-queue depth to BullMQ, heavy orchestration to Temporal, and raw streaming to other specialists—keeping this entry about Inngest-shaped durable workflows. Use it when a feature needs retries, delays, or multi-step side effects but you are not ready to operate workers 24/7. Bring an event shape, downstream APIs, and deployment target; the skill should steer handler structure, step boundaries, and operational concerns like concurrency and deduplication.899installs76LanggraphThe langgraph skill positions the agent as a LangGraph architect for production-grade, stateful multi-actor applications—the pattern LangChain recommends for agents and one used widely in industry. It walks through graph topology, careful state design with reducers, conditional branches, optional cycles, checkpointer-backed persistence, human-in-the-loop pauses, tool wiring, and error recovery, with emphasis on visible, debuggable flows rather than opaque prompt chains. Solo builders shipping agent products use it when moving from a demo chain to something that must resume sessions, audit decisions, and survive failures. The skill stresses when cycles are justified and how to cap runaway loops. It complements generic LLM prompting skills by focusing on executable graph structure, operational persistence, and integration boundaries suitable for APIs and internal automation services.896installs77Vulnerability ScannerVulnerability Scanner is a procedural security skill for solo and indie builders who ship web apps and APIs without a dedicated AppSec team. It trains the agent to think like an attacker while applying 2025-aware principles: assume breach, zero trust, layered controls, and fail-secure defaults. Before scanning, it prompts structured threat modeling—what you protect, who attacks, how, and business impact—then aligns work to OWASP Top 10 categories such as broken access control. Reference checklists cover authentication, APIs, and data protection; you can optionally run security_scan.py to validate that principles were applied on a local project tree. Use it during Ship security passes, pre-launch reviews, or Operate hardening when you need prioritization language rather than a random CVE dump. It complements automated SAST but does not replace professional penetration testing or compliance sign-off.855installs78Last30dayslast30days is an agent-oriented research skill from the Antigravity awesome-skills collection aimed at solo builders who need a fast pulse on what changed recently in AI tooling, models, and practitioner chatter. Prism’s ingested readme emphasizes API-shaped model catalogs and response payloads, which fits a workflow where your agent queries or simulates recent search results and returns titled links and summaries—such as community guides on Claude Code skills—rather than year-old blog posts. Use it when you are scouting a niche, validating whether a skill category is saturated, or choosing between model tiers before you wire integrations. It is not a full competitive intelligence suite or a scheduled monitoring product; it is procedural guidance for time-bounded discovery inside your coding session. Confidence is moderate because the public snippet is partial mock JSON rather than a full SKILL.md checklist.845installs79React Patternsreact-patterns packages modern React principles for solo builders who want agent-assisted code to match how production teams structure apps. It is not a code generator; it is a reference skill that steers decisions about component boundaries, when to extract custom hooks, where state should live, and which data layer fits the complexity budget. The guide aligns with contemporary stacks that mix server components, client interactivity, and shared server state via React Query or SWR. During Build, it helps prevent bloated containers and hook-order bugs; during Ship review, it gives a shared vocabulary for composition and performance fixes; during Validate prototypes, it keeps early UI from over-committing to global state. Risk is marked safe and source community—treat it as editorial guardrails you layer on top of your framework docs rather than a substitute for your linter or design system.841installs80Seo Fundamentalsseo-fundamentals packages a Python SEO checker that solo builders and small teams run against a codebase root to find on-page gaps before launch or content refreshes. It focuses on files that look like real public pages—static HTML and page-level JSX/TSX—while ignoring node_modules, build output, tests, and helper modules so results stay actionable. The audit covers meta titles and descriptions, Open Graph tags, logical heading order, and missing alt text on images, aligning with basics every indie SaaS or marketing site needs without paying for a separate crawler on day one. Use it when you have a Next or React marketing site, a docs landing zone, or mixed HTML exports and want a repeatable pre-ship checklist your coding agent can execute locally. It complements human SEO strategy rather than replacing keyword research or backlinks; treat findings as a fix list for your next commit.838installs81Geo Fundamentalsgeo-fundamentals packages a practical Generative Engine Optimization workflow for solo builders who care whether ChatGPT, Perplexity, and similar engines can quote their product pages accurately. The bundled checker walks the repository, filters to likely public routes in HTML and React page files, and flags missing signals that help generative systems attribute and summarize your content—structured data, visible author context, dates, and FAQ patterns. It deliberately ignores markdown documentation and test or config folders because those are not what AI crawlers treat as your marketed surface. Use it after you have real pages in the tree, especially marketing sites and SaaS landing routes, not as a substitute for traditional technical SEO or sitemap generation. The skill is checker-oriented: you run the script, interpret gaps, and fix templates or page metadata in your framework of choice.833installs82File OrganizerFile Organizer is an agent skill that helps solo builders tame chaotic Downloads folders, scattered project assets, and duplicate-heavy disks without reckless bulk deletes. It starts by understanding scope—which directories matter, what to avoid, and how aggressive cleanup should be—then reviews structure, hunts duplicates, and suggests layouts that match how you actually work. Smart moves and renames run with your explicit approval so current projects and sensitive paths stay safe. The skill is built for indie developers who juggle many repos and downloads on one laptop and need repeatable organization before archiving old work or kicking off a new codebase. Use it when discovery has broken down or duplication is eating storage, not when you only need a single rename. It complements git-based project structure; it does not replace version control or cloud backup policies.832installs83Autonomous Agentsautonomous-agents is an advanced agent-building skill sourced from vibeship-spawner-skills that teaches solo builders how to ship autonomous systems that stay dependable in production. It explains why extra decisions multiply failure probability—illustrated with the classic 95% per-step success collapsing to about 60% by step ten—and steers you toward constrained, domain-specific agents with explicit guardrails rather than autonomous everything. Coverage spans agent loops such as ReAct and Plan-Execute, goal decomposition, reflection patterns, logging for auditability, and fail-safe behaviors when tools or plans go wrong. The principles insist you expand capabilities only after guardrails exist and that critical paths keep humans in the loop. Use it when architecting or reviewing agent features, not as a one-click codegen shortcut.831installs84Lint And Validatelint-and-validate is a small Python-driven lint runner skill for solo builders who want one repeatable command instead of remembering per-stack tooling. The agent inspects the target directory, classifies the repo as Node or Python, then invokes the appropriate linters—package scripts, ESLint, TypeScript no-emit, Ruff, or mypy—so findings surface in a consistent format before merge or deploy. It fits indie SaaS, APIs, and CLIs where you ship frequently with an AI coding agent but still need human-trustworthy static analysis. Use it in the Ship phase when you are hardening a branch, refreshing CI parity locally, or validating a refactor did not introduce style or type errors. It is not a full test suite or security audit; it complements unit tests and review skills by automating the boring baseline checks every stack expects.820installs85Code Refactoring Refactor Cleancode-refactoring-refactor-clean positions your agent as a refactoring specialist grounded in clean code and SOLID, aimed at solo maintainers drowning in tangled modules before the next feature ships. The workflow starts with smell and dependency assessment, then proposes incremental steps, applies changes in narrow slices, and insists tests prove behavior stability—matching how indie teams actually reduce risk on legacy corners. Canonical placement is Ship/review because refactors are quality gates, but the same skill supports Build/backend when preparing modules for new capabilities. Skip it for trivial one-liners, frozen releases, or pure documentation tasks per the skill’s own guardrails. It complements lint-and-validate and dedicated code-review skills by focusing on design improvement rather than comment-only review or static analysis alone.819installs86Security AuditorSecurity-auditor is an agent skill that acts as a DevSecOps-focused security auditor for solo builders and small teams shipping web apps and APIs. It walks you through scoped reviews of architecture, threat models, and existing controls, then applies systematic data-flow tracing from entry points to storage so privileged paths cannot silently bypass database rules. Adversarial questioning targets defacement, hijacking, and exploitation scenarios, with explicit attention to insecure direct object reference on shared resources. The workflow blends targeted automated scans with hands-on verification, ranks issues by severity and business impact, and expects you to validate fixes after remediation. Use it when you have authorization to test and need more than a one-click scanner—especially for SDLC controls, CI/CD exposure, authentication, authorization, and data protection. Skip it when you lack written scope approval, need formal certification or legal sign-off, or only want a passive scan without interpretation.819installs87App BuilderApp Builder is an orchestrator skill that runs a fixed agent pipeline for solo and indie builders who want structured full-stack delivery instead of ad-hoc coding sessions. It starts with a Project Planner that must write a {task-slug}.md plan in the project root covering tasks, dependencies, and file layout, then enforces a plan verification checkpoint before any database, backend, or frontend specialists proceed. That gate reduces half-built repos and missing specs common when jumping straight to implementation. Use it when you are greenfielding or substantially restructuring an app and want one procedural workflow your Claude Code or Cursor agent follows end to end. It pairs naturally with planning and implementation skills but does not replace domain-specific security, testing, or deployment skills afterward.816installs88Production Code Auditproduction-code-audit is a community agent skill that tells your coding agent to autonomously discover the entire repository, infer tech stack and architectural intent, then work through security, performance, structure, and maintainability gaps until the codebase reads as production-grade. Solo builders reach for it when a side project grew messy, when an acquirer or enterprise client expects corporate polish, or when you are one deploy away from embarrassment. Unlike a single linter pass, the SKILL.md frames a multi-step ritual: read all files, map dependencies, classify issues, and apply systematic remediations. It belongs on the Ship shelf under review because user-facing triggers explicitly mention production deployment and professional standards, but the same pass informs Operate iteration when you are cleaning inherited code. Treat outputs as proposals—diff size and risk can be large—so pair human review with the skill’s breadth. Confidence is moderate because the excerpt truncates fix taxonomy; expect agent interpretation to vary by stack.810installs89Daily News ReportDaily News Report is an agent workflow skill that scrapes a configured URL list, filters for high-quality technical material, and aggregates a daily Markdown report. Architecture centers on a main orchestrator agent that schedules work, monitors sub-agents, evaluates quality, and writes cache files so repeat runs avoid re-fetching the same URLs within a TTL window. Solo builders use it to replace ad-hoc morning reading with a repeatable pipeline that still respects bandwidth and duplication. It spans Idea research for trend spotting, Grow content for newsletter fodder, and Operate iterate when you tune source priority from historical stats. Expect intermediate complexity: you configure sources, caching TTLs, and scraping behavior rather than clicking a single API button.809installs90Blockchain DeveloperBlockchain Developer is an agent skill for solo and indie builders who need production-grade Web3 guidance instead of fragmented chat answers. It walks through clarifying goals and constraints, applying smart-contract and decentralized-system best practices, and validating outcomes with actionable verification steps. Coverage spans Solidity advanced patterns, Rust contract work, DeFi and NFT platforms, DAO structures, and enterprise chain integrations, with security called out as a first-class concern. Use it when you are designing or implementing on-chain logic, wiring wallets and protocols, or hardening contracts before mainnet. Skip it when the task is unrelated to blockchain or you only need a non-Web3 stack. The README defers extended walkthroughs to an implementation playbook, so treat it as a structured expert persona plus checklist rather than a single codegen shortcut.803installs91Typescript Advanced TypesTypeScript Advanced Types is an agent skill that walks solo builders through TypeScript’s high-leverage type features—generics with constraints, conditional and mapped types, template literal types, and utility-type composition—using a structured implementation playbook. It is for developers who want library-grade safety in apps and shared packages: reusable components, inference-heavy helpers, API clients, validation layers, and configuration objects that fail at compile time instead of in production. Use it when you are building or refactoring TypeScript code and need patterns beyond basic interfaces, especially if you are extracting a framework-like module or tightening types after a JS migration. The skill emphasizes when each technique pays off (reusable generics vs. one-off types) and ties patterns to copy-paste-ready examples. It does not replace your compiler settings or bundler setup; it gives procedural knowledge your coding agent can apply file-by-file while you stay in the Build phase of the solo journey.803installs92Superpowers LabSuperpowers Lab is a lightweight agent skill that orients solo builders toward Obra’s Superpowers Lab repository as a playground for Claude superpowers—structured agent procedures, gates, and stack habits—before you commit those patterns to a shipping codebase. The SKILL.md is intentionally thin: it defines overview, when-to-use triggers, and hard boundaries so you do not treat lab output as production-ready without local testing. Install it when you are calibrating how superpowers-style workflows feel in your editor, comparing ritual steps, or prototyping skill combinations in isolation. It pairs naturally with other Superpowers-family skills (brainstorming, writing-plans, code review) once you graduate from the lab. Prism lists it for indie builders on Claude Code and similar agents who want a named entry point to the lab ecosystem rather than ad-hoc repo cloning.800installs93Tdd WorkflowTDD Workflow is an agent skill that encodes Test-Driven Development as a repeatable RED–GREEN–REFACTOR loop: write a failing test that names expected behavior, implement the smallest production change to pass, then refactor without changing behavior. It is aimed at solo and indie builders who ship features with Claude Code, Cursor, or Codex and want fewer regressions and clearer specs than ad-hoc “write code then add tests later.” Use it whenever you are implementing logic, APIs, or UI behavior where automated tests exist or should exist—not for one-off scripts you will never maintain. The skill stresses one assertion per test where possible, descriptive test names, and deferring optimization until green. It pairs naturally with debugging and code-review skills after refactors. On Prism it sits in the builder journey as a methodology bridge from Build implementation discipline into Ship-quality gates.796installs94Architect ReviewArchitect Review positions your coding agent as a master software architect who stress-tests major design changes for scalability, resilience, and maintainability across distributed systems. Solo builders use it when a feature touches service boundaries, data ownership, or platform standards—not when they only need a small module patch. The workflow gathers goals and constraints, surfaces architectural risks, and returns improvements with documented tradeoffs and validation follow-ups. Anti-patterns in the skill keep you from burning tokens on context-free opinions. It complements ordinary code review by focusing on integrity of the whole system rather than syntax.794installs95Content CreatorContent Creator packages a fill-in monthly content calendar for solo builders and small teams who need structure without a full CMS. It breaks the month into weekly grids with Monday-through-Friday slots across blog, LinkedIn carousels, newsletters, X threads, and coordinated Friday campaigns, each with status checkboxes and timing hints. Monthly goals anchor traffic, lead, and engagement targets, while a content bank captures future ideas. The closing performance review section forces you to record what worked and what to adjust next month—useful when an agent helps you draft plans from a blank template or migrate an existing editorial rhythm into a consistent markdown artifact you can version in git.793installs96Ai EngineerAI Engineer is an agent skill that positions the assistant as a production-focused AI engineer for solo and indie builders shipping LLM-powered products. Invoke it when you are building or improving LLM features, RAG systems, or AI agents; designing integration architecture and model selection; or tuning embeddings, vector search, and retrieval pipelines with cost and monitoring in mind. The skill walks through clarifying use cases and success metrics, designing data flow and model choices, implementing with safety guardrails, and validating via tests plus staged rollout. It explicitly excludes pure data-science or classical ML without LLMs and quick UI edits unrelated to AI. Safety guidance stresses approval before exfiltrating sensitive data to external APIs and adding controls for prompt injection and PII. Complexity is advanced because production AI spans retrieval quality, agent coordination, observability, and compliance. After Build implementation, the same framing supports Ship security review and Operate monitoring of model spend and failures.790installs97Frontend DeveloperFrontend-developer is a community agent skill that positions the model as a modern web UI specialist for React 19+, Next.js 15+, and the surrounding ecosystem. Solo builders reach for it when they need real implementation guidance—component structure, state and data fetching, responsive layouts, and fixes for performance or accessibility—not when they only want API design or native mobile stacks outside the web. The instructions ask you to clarify devices and performance goals, pick state and data approaches, build with a11y and breakpoints in mind, then validate with profiling and audits. Capabilities emphasize concurrent features, RSC, and advanced performance tuning alongside classic component work. Skip it for backend-only tasks or pure visual design without code. It fits Prism’s Build journey shelf for founders shipping SaaS dashboards, marketing sites, or browser extensions who use Claude Code or Cursor as their primary frontend pair programmer.790installs98Business AnalystBusiness Analyst is an agent skill package for solo and indie builders who need credible business intelligence without hiring a full-time analyst. It instructs the agent to clarify goals, constraints, and inputs, then apply modern analytics practices—dashboard design, KPI frameworks, predictive modeling, and narrative recommendations that tie metrics to decisions. The SKILL.md positions you as an expert business analyst blending technical analytics fluency with business acumen, suitable when you are sizing a market, refining pricing, planning growth experiments, or diagnosing operational inefficiency. It is intentionally not a single API integration; it is procedural guidance and checklists you invoke when business-analysis work appears in the thread. Use it when you want structured, verifiable steps rather than ad-hoc spreadsheet chat. Skip it when the task is pure engineering with no business-metrics angle. Deeper worked examples live in the bundled implementation playbook resource.788installs99Radix Ui Design Systemradix-ui-design-system encodes how solo builders wire Radix UI primitives into React apps with accessibility and structure first. The documented flow centers on `@radix-ui/react-dialog`: a trigger opens a portaled overlay and content region, with mandatory Title and recommended Description for screen readers, plus styled form fields inside the modal. It demonstrates asChild on triggers, separation of overlay and content layers, and CSS class extension points—patterns that extend across other Radix packages in the same design-system family. Use it when your agent would otherwise paste brittle custom modals or skip ARIA semantics. It is reference-oriented frontend knowledge, not a full component library install guide; pair it with your stack’s bundler, icons (`@radix-ui/react-icons`), and theme tokens.786installs100Testing PatternsTesting-patterns is a community agent skill that encodes Jest-oriented unit testing conventions, factory helpers, mocking strategies, and a strict Test-Driven Development loop for solo builders shipping TypeScript or React Native apps. It opens with philosophy: red-green-refactor, behavior over implementation, and factory functions that keep suites maintainable. Concrete utilities include a custom render that wraps components with theme or other providers, plus guidance on descriptive test names aligned to business behavior. Use it when you are adding unit tests, designing test factories, or explicitly following TDD—not when you only need E2E or manual QA checklists. The examples skew toward React Native Testing Library but the patterns transfer to Jest DOM setups. Expect intermediate familiarity with mocks, partial overrides, and what belongs in public API tests versus brittle internals.775installs101Shopify Appsshopify-apps is an expert-pattern agent skill for solo builders shipping on Shopify’s platform. It condenses how to stand up a modern app with the Shopify CLI, organize routes for auth callbacks and webhooks, and configure shopify.app.toml scopes and URLs so OAuth and subscription billing do not become guesswork. The skill emphasizes embedded experiences via App Bridge, Polaris-aligned UI, GraphQL Admin API access, and extension surfaces merchants actually install. Antigravity positions it for the moment you start a new Shopify app—when template structure, server-side shopify.server.ts wiring, and webhook durability matter more than marketing copy. Risk is marked safe and the content traces to vibeship-spawner-skills under Apache 2.0. Use it as a pattern library while you implement catalog, order, or fulfillment features rather than as a replacement for Shopify’s official CLI docs when APIs change.764installs102Performance ProfilingPerformance Profiling teaches solo builders to measure, analyze, and optimize in strict order so fixes target real bottlenecks instead of folklore. It centers on Core Web Vitals—LCP for loading, INP for interactivity, CLS for stability—with explicit good and poor thresholds and guidance on when to use local Lighthouse during development, Lighthouse CI in pipelines, and RUM in production. The four-step loop (baseline, identify, fix, validate) pairs with a tool picker: Lighthouse for page load, bundle analyzers for dependency weight, and Chrome DevTools for runtime, memory, and network issues. An included Python script wraps Lighthouse audits for repeatable CLI checks. Use this skill when shipping customer-facing web apps, when regressions appear after dependency upgrades, or when SEO and UX both depend on vitals. It is principles plus optional automation, not a hosted monitoring product.760installs103Unreal Engine Cpp ProUnreal Engine C++ Pro is an agent skill aimed at solo and indie game builders who ship native Unreal modules alongside Blueprints or pure C++ titles. It encodes practical Unreal conventions: correct A-prefix actors, CreateDefaultSubobject for components, tick off unless gameplay requires it, cache player controllers in BeginPlay, and tear down in EndPlay. The skill helps Claude Code, Cursor, or Codex generate snippets that compile cleanly against CoreMinimal, GameplayStatics, and generated UObject headers. Use it when scaffolding new actors, refactoring hot paths, or reviewing agent-written gameplay code before you merge into a UE5 project. It matters because agent-generated C++ often mis-ticks, logs without categories, or scatters lookups in Tick—patterns that hurt performance and fail code review on a small team where one person owns both design and engine code.758installs104Concise PlanningConcise Planning is a lightweight planning ritual for solo builders who want clarity before an agent touches code. It instructs the agent to read project context, avoid questionnaire sprawl, and emit a single markdown plan with approach, bounded scope, six to ten ordered tasks, and explicit validation. The output is tuned for Cursor- or Claude Code-style execution: checkbox action items that name real files and end with test or verify steps. Use it when a task feels fuzzy, when you are mid-build and need a reset, or when validating scope before a prototype spike. It does not replace deep architecture reviews or security audits—it optimizes for fast, citable plans that fit indie shipping cadence.757installs105Code Documentation Code ExplainCode Documentation Code Explain is an agent skill playbook for analyzing source so you can explain it accurately to teammates, users, or your coding agent. It walks through code comprehension analysis: scoring complexity, listing concepts and design patterns, and summarizing dependencies with optional AST-based metrics like cyclomatic complexity and max nesting. Solo and indie builders use it when inheriting a repo, preparing onboarding docs, or drafting review notes without guessing what a module does. The skill is procedural knowledge—not a live linter—so you point it at snippets or files and get a structured narrative aligned with documentation and quality gates elsewhere in the journey. Pair it with your doc generator or review skill after analysis when you want human-readable output in your repo’s style.754installs106Autonomous Agent Patternsautonomous-agent-patterns is a community-sourced design-pattern skill for builders creating autonomous coding agents modeled after Cline and OpenAI Codex. It is aimed at solo developers and small teams who need more than ad-hoc prompts: a repeatable loop, explicit decision points, tool surfaces, and guardrails before agents touch shells, repos, or browsers. The material walks through core agent architecture, planning and execution separation, observation of results, and patterns for approvals and human oversight. Use it whenever you are sketching a new agent runtime, extending an IDE agent with custom tools, or hardening permissions after a scary autonomous run. The skill is conceptual and architectural rather than a single integration, so it pairs with implementation work across Build, Ship, and Operate as you add monitors and tighten policies.747installs107Kubernetes Architectkubernetes-architect is an agent skill that behaves like a staff platform engineer in chat form. It helps solo and indie builders who have outgrown single-node deploys define cluster topology, networking, security, and GitOps-driven delivery using ArgoCD or Flux. The workflow starts with requirements and compliance, then selects multi-cluster or single-cluster patterns, admission policy, and mesh options where warranted. It emphasizes progressive rollouts, cost and reliability tradeoffs, and developer experience—not just YAML snippets. Skip it for local minikube hacks or pure application bug hunts with no platform change. Use when you are committing to Kubernetes in production and need an auditable path from design through staged validation and rollback drills.730installs108Ai ProductAI Product is a methodology skill for solo and indie builders shipping LLM-powered features. It argues every product will touch AI, but production success depends on integration discipline rather than demo polish. The skill walks principles: design for output variance with validation layers, manage prompts like code with tests and experiments, default to RAG for updatable knowledge, and pair trustworthy AI UX with cost controls. It is not a single API wrapper—it is procedural knowledge for scoping and building agentic or SaaS features that survive real users and spend. Use when you are deciding architecture, hardening prompts, or reviewing whether a prototype should go live. Antipatterns called out include parsing LLM JSON straight into databases and keeping prompts inline without tests.729installs109Javascript MasteryJavaScript Mastery packages a solo-builder-friendly reference to more than thirty essential JavaScript ideas, inspired by the well-known 33-js-concepts list. Install it when you need an agent that can explain how primitives, coercion, scope, and other fundamentals actually behave—not vague chat answers. It fits whenever you are building a web app, extension, or small CLI in JS and hit language quirks, or when you want teaching-quality explanations for yourself or a teammate. The skill is procedural knowledge: it steers the agent through structured explanations, debugging reasoning, and best-practice review rather than generating boilerplate. Because JavaScript spans your UI and often your API layer, the same material remains useful later in Ship when you review diffs for foot-guns. It does not replace a linter or test suite, but it shortens the loop from “why did this break?” to a correct mental model so you ship fewer subtle runtime bugs.726installs110Twilio CommunicationsTwilio Communications is a build-phase integration skill for solo founders who need real outbound and inbound comms without learning Twilio’s docs by trial and error. It walks the full spectrum from simple SMS notifications and transactional alerts to voice IVR, WhatsApp Business messaging, and verification flows suitable for 2FA—always with emphasis on compliance, throughput limits, and structured error handling rather than happy-path demos. The SMS pattern spells out E.164 phone formatting, default rate limits around eighty messages per second, multi-segment billing past 160 characters, and carrier filtering risks that bite US routes. You should reach for it when your SaaS or mobile-backed API needs order updates, appointment reminders, or phone-based login, and you want agent-guided implementations that respect TwilioRestException cases and callback hooks instead of one-off scripts that fail silently in production.723installs111Seo AuditSEO Audit is an agent skill that positions your coding agent as an SEO diagnostic specialist for solo builders shipping landing pages, docs sites, or small SaaS marketing properties. It forces a scope gate up front—business model, markets, whether you need technical versus content depth, and what analytics you can share—so the audit does not pretend to omniscience. The framework walks crawlability and indexation first, then technical foundations, on-page optimization, content quality and E-E-A-T, and authority signals, producing prioritized findings rather than a laundry list of generic tips. It explicitly avoids implementing fixes unless you ask, which keeps the skill useful as a planning input for developers using Cursor or Claude Code alongside separate implementation skills. Use it after migrations or redesigns, when traffic plateaus, or before a launch checklist when you need a sober view of what blocks organic growth.722installs112Frontend Ui Dark TsFrontend UI Dark Theme (TypeScript) is an agent skill that encodes a modern dark React interface system for solo builders shipping dashboards, admin panels, and dense data views. It centers on Tailwind CSS for layout and tokens, Framer Motion for restrained animation, and Vite with the react-ts template for fast local iteration. The readme specifies pinned major versions across react, react-dom, react-router-dom, clsx, tailwindcss, and typescript so agents do not mix incompatible stacks. Quick start commands cover project creation, dependency installs, and Tailwind PostCSS wiring, while the public folder section reminds you to ship favicons, Open Graph images, and a web manifest for credible launch polish. Use it when you want a cohesive dark glass aesthetic without hiring a design system team—your agent applies the structure and styling patterns inside your new or existing Vite app.719installs113Computer Use AgentsComputer Use Agents is an agent skill for solo builders experimenting with AI that operates a real desktop like a human—seeing the screen, moving the cursor, clicking, and typing. It centers on the perception-reasoning-action loop: capture state, let a vision-language model plan, execute input events, then re-observe outcomes. Coverage spans Anthropic Computer Use, OpenAI Operator and CUA-style stacks, and open-source paths, with repeated emphasis on sandboxing and the security risks of unconstrained GUI automation. The SKILL.md calls out a practical behavior pattern: agents appear frozen for roughly one to five seconds during reasoning, which matters for UX and detection. Use it in Build when you are prototyping browser or OS automation that cannot be reduced to a REST tool, and you need architectural guardrails before Ship security review. It complements tool-builder skills by addressing modalities function schemas do not cover.715installs114Rag EngineerRag-engineer is a specialist agent skill for solo builders shipping AI products that must answer from private documents without hallucinating boilerplate. It frames the architect role: chunk boundaries, embedding dimensions, similarity metrics, and hybrid retrieval often matter more than the choice of chat model. The skill walks through embedding model tradeoffs, vector database scaling patterns, content-type-specific chunking, re-ranking and metadata filters, and how to budget context windows so agents see the right passages—not the longest ones. It encodes explicit principles such as evaluating retrieval independently from generation and preferring hybrid search over pure semantic retrieval in most real-world corpora. Use it while designing agent backends, customer-support bots, or internal copilots, then carry the same retrieval discipline into ship-phase testing and operate-phase monitoring when drift or stale indexes appear.715installs115Agent Tool BuilderAgent Tool Builder is an agent skill for solo and indie builders who wire custom capabilities into Claude Code, Cursor, Codex, and similar agents. It walks from JSON Schema shape through description writing, validation, and error handling—the layers that decide whether an agent invokes the right tool or hallucinates a call. The SKILL.md stresses that description quality usually beats implementation polish because the LLM only sees schema and natural-language intent. You get principles for keeping tool catalogs small, returning string payloads, and gating execution when inputs are invalid. MCP is framed as the lingua franca for portable tool surfaces. Use it when you are authoring new tools, tightening an existing function-calling set, or aligning a local skill package with MCP expectations before you ship an agent workflow to production.714installs116Flutter Expertflutter-expert is a community-sourced agent skill that positions the model as a senior Flutter developer for Dart 3 and Flutter 3.x. Solo builders invoke it when clarifying goals, constraints, and inputs before applying checklists and best practices across widgets, state, navigation, and deployment surfaces. It emphasizes high-performance multi-platform delivery—Impeller-oriented rendering notes, engine embedding, and advanced composition—while keeping one codebase across phone, web, and desktop targets. The skill tells agents to open the implementation playbook when detailed examples are required, which keeps routine answers actionable without dumping entire manuals. It does not replace platform store policies, native plugin debugging outside Flutter, or backend API design; pair it with testing and release skills before production ship.713installs117Skill Creatorskill-creator is a meta agent skill for people who ship procedural knowledge as installable SKILL.md packages rather than ephemeral chat instructions. Antigravity-style skill-creator entries typically walk you from idea to structured skill: name and description tuned for automatic invocation, license and metadata blocks, body sections for triggers, steps, and outputs, then refinement after the agent uses the skill on real work. Solo builders reach for it in Build when standing up a new integration or checklist, again in Ship when hardening review or test skills before wider distribution, and in Operate when updating skills after production learnings. It does not replace domain skills—it teaches how to capture your playbook so Cursor, Claude Code, or Windsurf picks it up consistently. Expect intermediate complexity: you need a repo, clear triggers, and willingness to edit markdown until invokeWhen fires reliably. Published install stats and audits live on the Prism detail page separately from this editorial tag set.712installs118Stripe IntegrationStripe Integration is a community agent skill that teaches robust, PCI-minded Stripe wiring for solo builders shipping SaaS, mobile backends, or marketplaces. It fits when you are implementing checkout, recurring billing, webhook-driven entitlement updates, refunds, or Connect splits—not when the task is unrelated infrastructure. The skill contrasts fast hosted Checkout Sessions against custom Payment Intents UIs, and it surfaces operational concerns like Strong Customer Authentication and dispute handling that indie teams often discover late. Instructions emphasize clarifying goals, constraints, and inputs before coding, then validating outcomes with actionable verification steps. Open the bundled implementation playbook when you need deeper examples. Use it during Build while integrating APIs, during Validate when proving pricing and paid prototypes, and during Ship when hardening webhook idempotency and launch billing checks.711installs119Agent Manager Skillagent-manager-skill is a procedural agent skill for solo builders who outgrow a single Claude Code or Codex terminal and need a lightweight ops layer on the laptop. After cloning fractalmind-ai/agent-manager-skill into the workspace, you use Python entrypoints to verify dependencies, enumerate configured agents, boot them in isolated tmux panes, stream logs with monitor --follow, and pipe multi-line instructions into assign. That pattern fits active Build sprints where frontend, backend, and research agents should run concurrently without hand-switching tabs. It also spans Operate when you want cron-triggered maintenance agents following team workflow markdown. The skill explicitly scopes itself: use only when parallel local CLI agents and tmux orchestration match the task, and treat output as needing your own validation. It is integration-style workflow glue, not a hosted agent platform or cloud scheduler.702installs120Git PushingGit Pushing is a narrow workflow skill for agent-assisted repos: when you say push this, commit and push, save to GitHub, or finish a feature you want on the remote, the agent must run the bundled smart_commit.sh instead of improvising git steps. That enforces one path—stage everything, emit a conventional commit (default or your message), append the documented footer, and push with upstream set. Solo builders use it to stop half-pushed branches and inconsistent commit styles during Ship. The skill is explicit that missing permissions, unclear success criteria, or out-of-scope tasks should pause for clarification rather than forcing a push. It does not replace code review, CI, or conflict resolution; it is the last-mile sync after you trust the diff. Because the catalog marks critical risk, treat remote writes as irreversible until you verify branch and remote.700installs121Bash Probash-pro is an agent skill that turns your coding agent into a defensive Bash reviewer and author for real automation—not throwaway one-liners. It walks through defining inputs, outputs, and failure modes, enabling strict error handling, validating untrusted input, and avoiding eval and unsafe globbing. The skill emphasizes portable patterns where possible, safe file and temp resource handling, pipeline safety, and production-grade logging so CI jobs fail loudly and predictably. It explicitly pairs implementation with Bats tests and ShellCheck linting, and calls out when to reach for a higher-level language, POSIX-only shells, or PowerShell on Windows instead. Solo and indie builders shipping scripts alongside GitHub Actions, release tooling, or server maintenance get a repeatable checklist that hardens scripts before they touch production data or customer environments.695installs122Agent EvaluationAgent Evaluation is an agent skill for indie builders shipping Claude Code, Cursor, or Codex workflows who need more than vibe checks before going live. It covers behavioral testing, capability assessment, reliability metrics, and production monitoring—areas where even strong agents often score below half on realistic benchmarks. The skill maps to established evaluation tooling (AgentBench, τ-bench, ToolEmu, Langsmith) and stresses prerequisites such as testing-fundamentals and llm-fundamentals. It deliberately excludes training-time metrics, fairness audits, and pure UX studies so you stay focused on whether your agent completes multi-step tasks safely and consistently. Use it when you are hardening a custom agent, comparing orchestration patterns, or setting up regression runs after prompt or tool changes. Outcomes include clearer pass/fail criteria, traceable eval runs, and hooks for ongoing monitoring rather than one-off demos.693installs123Backend Security Coderbackend-security-coder is an agent skill that positions your coding agent as a security-minded backend implementer, not a passive linter. It applies when you are writing or reviewing server-side code where input validation, authentication, API boundaries, database access, and error responses can become exploit paths. Instructions tell the agent to clarify goals and constraints, apply best practices, and return verifiable steps—suitable for solo founders who cannot afford a separate appsec hire on every feature. The skill explicitly pairs with a broader playbook file for richer examples while keeping the SKILL.md entry lightweight. Use it proactively during Ship security work and while implementing sensitive Build backend paths. Skip it when the task is unrelated to backend security or when you need a non-coding security audit-only engagement without implementation guidance.692installs124Red Team TacticsRed Team Tactics is an agent skill that teaches adversary-simulation principles grounded in the MITRE ATT&CK framework for builders who need structured red-team thinking during authorized work. It walks through attack lifecycle phases—from reconnaissance and initial access through execution, persistence, privilege escalation, defense evasion, credential access, discovery, lateral movement, collection, command and control, exfiltration, and impact—with explicit phase objectives so assessments stay goal-oriented rather than checklist theater. The skill contrasts passive versus active reconnaissance and frames reporting and detection evasion as part of a disciplined engagement, not casual exploitation recipes. It is aimed at solo and indie developers, small security-minded teams, and agent operators running defensive validation or tabletop-style exercises in permitted environments. Use it when you want your Claude Code or Cursor session to reason about attack surface, footholds, and detection gaps using shared industry vocabulary, while keeping scope legally and contractually bounded.690installs125Voice Ai DevelopmentVoice AI Development is an agent skill that acts as a voice-AI architect for solo builders shipping conversational or hands-free experiences. It spans provider selection and implementation patterns for OpenAI’s Realtime API, Vapi for agent orchestration, Deepgram for transcription and speech, ElevenLabs for synthesis, and LiveKit plus WebRTC for low-latency streaming infrastructure. The skill stresses latency budgets, audio quality trade-offs, and user-perceived responsiveness because voice products fail loudly when round-trip delay spikes. It is suited to indie founders building support agents, meeting copilots, or voice-first SaaS features who need an integrated mental model rather than disconnected API snippets. Use it while scaffolding async audio pipelines, comparing STT/TTS stacks, and hardening real-time sessions before launch, with Claude Code or Cursor agents that must reason across vendors instead of optimizing a single REST call.690installs126Codebase Cleanup Refactor CleanCodebase Cleanup Refactor Clean is a implementation playbook for solo builders who inherited or rushed a feature and now need disciplined refactoring without rewriting everything blindly. It walks agents through a three-part analysis: catalog code smells with explicit thresholds such as methods over twenty lines and classes over two hundred lines, audit SOLID principle violations, and flag performance risks from quadratic loops through missing caches. The strategy section forces prioritization—constants and naming first, then extraction of duplicated and oversized procedures—with concrete Python-style before and after examples for order-processing flows. Invoke it during Ship review before a release candidate merge, or mid-Build when a module blocks new work. It complements linters by supplying narrative rationale auditors and future-you can follow, but it does not replace automated test suites; run tests after each refactor slice.685installs127Api Design Principlesapi-design-principles packages a pre-implementation API review as an agent skill for indie builders who are about to expose HTTP resources to mobile apps, partners, or their own frontend. Instead of debating verbs versus nouns in chat, the skill walks plural resource naming, shallow hierarchies, correct GET/POST/PUT/PATCH/DELETE usage, and a practical status-code matrix from 201 Created through 422 validation failures. It pushes collection endpoints toward real pagination metadata, filter and sort query parameters, and an explicit versioning choice so you do not paint yourself into a breaking-change corner on day one. Use it while scoping an MVP API or right before generating OpenAPI from a greenfield backend. The outcome is a coherent contract mindset your agent can mirror when scaffolding routes, error handlers, and client SDKs—without pretending every checklist item is already implemented in code.678installs128Database ArchitectDatabase Architect is an agent skill that acts as an expert data-layer advisor for solo and indie builders who need to choose storage technology, model schemas, and plan scalable persistence from scratch or during a re-architecture. It is built for moments when query tweaks are not enough—you are selecting between Postgres, document stores, or hybrid patterns, defining partitions and replication, or preparing a migration that must not brick production. The workflow starts by documenting the data domain, read/write access patterns, and growth targets, then recommends an architecture pattern, concrete schema and indexing design, and operational policies for backups and rollouts. It explicitly avoids scenarios where you cannot change the model or infrastructure, or where you only need application feature design without touching persistence. For builders shipping SaaS APIs, agent backends, or data-heavy features, the skill keeps decisions performance-first and maintainable while stressing staged migration validation and non-destructive change discipline.675installs129Clerk Authclerk-auth is an agent skill that encodes expert Clerk authentication patterns for solo builders shipping Next.js SaaS products. It targets indie developers using Claude Code, Cursor, or similar agents who need ClerkProvider, route-level sign-in and sign-up pages, and environment variable conventions without reading the entire Clerk docs each session. Invoke it during Build when you are integrating Clerk middleware, organizations, webhooks, or syncing users to your database—after you have a basic App Router app but before you treat auth as done for Ship. The skill emphasizes copy-paste-ready layout and page examples plus redirect URLs that match common dashboard and onboarding flows. It does not replace Clerk dashboard configuration, key rotation, or security review in Ship. Use it to standardize how your agent proposes auth code so production secrets stay in env files and UI flows stay consistent across sessions.662installs130Server ManagementServer Management is a principles-first agent skill for solo and indie builders who self-host or run VMs alongside managed platforms. Instead of dumping copy-paste commands, it frames how to choose supervisors for Node.js versus Linux-native systemd versus containers, and what “good” operations means: auto-restart on failure, graceful reloads, multi-core clustering, and surviving reboots. It pairs that with a concise monitoring mindset—what to measure (uptime, latency, error mix, CPU/memory/disk) and how to tier alerts so you are not paging yourself for noise. Use it when you are about to deploy a side project to a single server, outgrow a hobby setup, or compare cheap observability against full stacks. The readme explicitly teaches decision-making over memorization, which makes it a useful companion to deployment skills and runbooks you will refine in Operate.662installs131React Nextjs DevelopmentReact Nextjs Development is a granular workflow bundle for solo and indie builders shipping React and Next.js 14+ apps with App Router, Server Components, TypeScript, and Tailwind CSS. It walks through documented phases—beginning with project setup (tool choice, scaffold, TypeScript, lint/format) and continuing into component architecture—while naming companion skills to invoke for scaffolding, router patterns, and implementation depth. Use it when you are starting a new frontend or full-stack Next.js codebase and want a repeatable ritual instead of one-off agent prompts. The workflow fits Prism’s Build journey shelf because it concentrates on creating the product surface and structure, not distribution or production ops. Pair it with your agent’s existing fullstack or pattern skills for API routes and data layers when the readme’s full-stack scenarios apply.661installs132Ai Wrapper Productai-wrapper-product coaches solo builders on turning LLM APIs into focused tools people pay for. It treats the wrapper as a real product: a stack where model choice, prompts, guardrails, metering, and UX jointly define value—not a thin reskin of a chat UI. The skill covers when to architect an AI-powered offer, how to engineer prompts for reliable product behavior, how to balance inference cost against experience, and how to meter usage so margins stay sane as you grow. It speaks to indie founders who need a defensible niche (specific workflow, audience, or data loop) instead of competing on “another GPT.” Use it while scoping what to build, then carry the patterns into backend integration and agent-facing flows. It does not replace legal review for data handling or provider terms—you still own compliance and API key hygiene.655installs133Planning With FilesPlanning with Files is an agent skill that turns fuzzy requests into durable markdown artifacts—typically task_plan.md for goals and phases, notes.md for raw findings, and a final deliverable file. Solo and indie builders install it when Claude Code, Cursor, or Codex would otherwise wander mid-task or lose context across long sessions. Each loop starts by re-reading the plan to refresh intent, then performs scoped work (search, code, synthesis), persists outputs to disk, and edits the plan to mark progress. That pattern mirrors serious PM discipline without a separate tool stack: you get explicit phases, open questions, and a single source of truth the agent can reload. Use it whenever a job has more than one meaningful step—market research, feature implementation, incident response—not only for greenfield specs. It pairs naturally with brainstorming or spec skills upstream and with implementation skills downstream once phases are checked off.655installs134Agent Orchestration Multi Agent OptimizeAgent-orchestration-multi-agent-optimize is an advanced skill for solo builders and small teams running more than one agent in production workflows. It targets measurable pain: slow handoffs, uneven workload, runaway token cost, or fragile coordination when tasks fan out across specialists. The workflow starts by establishing baseline metrics and goals, profiles where agents wait on each other or misuse context, then applies orchestration and cost controls in small steps with repeatable tests and explicit rollback plans. It is not for tweaking a single system prompt or for projects with no evaluation data. Safety guidance stresses regression testing and gradual rollout so one orchestration change does not take down the whole pipeline. Use it when you already have multi-agent traffic and need engineering discipline—similar to perf work on a microservice mesh, but for agent graphs.654installs135Voice AgentsVoice-agents teaches solo and indie builders how to ship conversational voice interfaces where latency and turn-taking dominate user trust. The skill contrasts speech-to-speech paths (OpenAI Realtime API) for minimal delay and natural prosody against modular pipelines (STT→LLM→TTS) that are easier to debug and swap vendors. It emphasizes sub-800ms response expectations, jitter awareness, voice-activity detection quality, barge-in handling, and starting with a focused MVP before expanding telephony or analytics. Builders use it while integrating providers, designing session state, and hardening audio edge cases; performance tuning and monitoring naturally continue into Ship and Operate. The upstream note that 84% of organizations are increasing voice AI budgets in 2025 frames why getting architecture right early matters for indie products betting on voice as a primary channel.653installs136Code ReviewerCode Reviewer is an agent skill aimed at solo builders who merge their own PRs and need elite, structured review without a human team on call. It frames the reviewer as a master of modern analysis—AI-powered assistants, static analysis integrations, and reliability practices—so assessments go beyond lint toward bugs, vulnerabilities, and incident-prone patterns. Instructions require clarifying goals and constraints, applying best practices, and returning verifiable next steps; optional depth lives in an implementation playbook resource. Invoke it on Ship when a feature branch is ready, or during Build when you want a self-review pass before opening a PR. Skip when the task is unrelated to reviewing code or when you need domain tooling outside review scope. Pair with your repo’s CI and security scanners; the skill orchestrates judgment, not replacement of automated gates.651installs137Web Design GuidelinesWeb Design Guidelines is an agent skill that keeps solo builders aligned with Vercel’s Web Interface Guidelines without manually re-reading a moving spec. On each review it retrieves the current command.md from GitHub, reads the files you point at, and reports violations in the compact file:line format the guidelines define—ideal for pre-merge UI passes on marketing sites, dashboards, and extensions. Use it when you want a consistent accessibility and interface hygiene check across React or web projects, especially when guidelines update frequently. The skill explicitly stops short of replacing environment-specific testing, visual QA, or expert accessibility audits, so pair results with your own keyboard, screen reader, and cross-browser checks.648installs138Doc Coauthoringdoc-coauthoring is a journey-wide agent skill that structures collaborative document creation so solo builders do not ship specs and proposals that only make sense inside a long chat thread. Claude acts as an active guide through Context Gathering (collect facts and constraints with clarifying questions), Refinement & Structure (section-by-section brainstorming and editing), and Reader Testing (evaluate the draft with a context-free reader stand-in to catch ambiguity before stakeholders see it). The skill triggers when users mention writing documentation, PRDs, design docs, decision records, or RFCs—or when they start a substantial writing task. It fits validate when scoping and pricing need a written artifact, build when producing implementation specs, and ship when security or launch prep needs reviewable RFCs. Complexity is beginner-friendly on process discipline while outcomes improve intermediate teams who already know what they want to say but need editorial rigor. Offer the workflow explicitly; respect if the user prefers freeform.645installs139Architecture PatternsArchitecture Patterns is an agent skill packaged as an implementation playbook for solo builders whose SaaS or API has outgrown a flat src folder. It explains Clean Architecture dependency direction, Hexagonal ports and adapters for testable infrastructure swaps, and Domain-Driven Design from bounded contexts down to aggregates and domain events. The intent is to steer Claude Code or Cursor toward folders and boundaries that keep business rules independent of Next.js, ORMs, or payment SDKs—so you can mock adapters in tests and replace vendors later. Canonical placement is Build (backend), but it is honestly multi-phase: during Validate you can name contexts and language before writing features, and during Ship review you can check whether new code respected layer rules. It is not a deploy or SEO skill; it is structural design knowledge for maintainable indie products.644installs140Deployment ProceduresDeployment Procedures is an agent skill that teaches production deployment as decision-making, not a single script. Solo and indie builders use it when they are about to ship a static site, simple web app, containerized service, or serverless workload and need a repeatable mental model: pick the right host, run structured pre-flight checks, execute a platform-appropriate release, and know how to roll back if signals go wrong. The skill stresses that every stack differs—Vercel git push, Railway CLI, VPS plus PM2, Docker registries, or Kubernetes apply each imply different failure modes and verification steps. It aligns with the Prism journey at Ship (launch) and bleeds into Operate when releases are recurring. Risk is marked critical in metadata, so the agent should emphasize verification and rollback over speed. Install it when you want your coding agent to reason through releases with you rather than hallucinate a generic deploy one-liner.644installs141Prompt CachingPrompt Caching is a reference skill for LLM-specific caching strategies spanning Anthropic native prompt caching, response caching in Redis, and Cache Augmented Generation (CAG) workflows. Solo builders shipping agents or API backends use it when system prompts, tool schemas, or retrieval prefixes stay stable while user queries change—exactly the cost curve that hurts at scale. The document maps when to cache prefixes versus full responses, names ecosystem tools, and draws hard boundaries away from CDN and database caching so implementers do not mix concerns. It pairs naturally with context-window management when you are optimizing both window usage and billed tokens. Intermediate builders integrating @anthropic-ai/sdk or similar clients get concrete pattern guidance rather than a one-click integration.643installs142Claude Scientific SkillsClaude Scientific Skills is a compact agent skill that tells Claude Code, Cursor, and similar agents how to approach scientific research and analysis tasks within a clearly matching scope. Solo builders and indie researchers install it when they want procedural nudges aligned with the K-Dense-AI claude-scientific-skills project instead of improvising methodology in chat. The SKILL.md directs use only when the task obviously fits scientific research and analysis, and it warns against treating outputs as a replacement for environment validation, testing, or expert review. Because the bundled instructions are high level, the skill works best as a routing and quality bar layer while you pull detailed protocols from the linked GitHub repository. Intermediate users benefit most when they already know their domain constraints and need the agent to stay in a research-safe posture across ideation and early build documentation.640installs143Notion Template BusinessNotion Template Business is an agent skill for solo creators who want more than a free Notion page—it treats templates as digital products with pricing, distribution, and support systems. Canonical placement is validate and pricing, where you decide what problem the template solves, how to package tiers and bundles, and what price matches perceived value before you polish every block. The skill also spans build (template structure and Notion features), launch (Gumroad, Lemon Squeezy, and marketplace strategy), and grow (marketing and repeatable support). It emphasizes sustainable revenue: documentation, bundle strategies, and operations that do not collapse when sales spike. Indie builders wearing every hat can use it to avoid underpricing, vague positioning, or launching without a fulfillment path. It is methodology and go-to-market guidance, not a Notion API integration or automated template generator—your agent should produce business and design decisions you implement in Notion and your payment platform.637installs144Architecture Decision RecordsArchitecture Decision Records is a documentation skill that teaches repeatable patterns for creating and maintaining ADRs—short, durable records of why you chose a framework, data store, auth model, or integration approach. Solo builders use it at decision time so six months later you remember constraints and rejected options, not just the final pick. The workflow starts with context and drivers, documents considered alternatives with tradeoffs, records the decision with rationale and consequences, then links related ADRs and updates status as reality changes. Skip it for trivial patches or implementation trivia called out explicitly in the skill. It shines during validate scoping, build architecture work, and operate iterations when you revisit past bets. Beginner-friendly structure with intermediate payoff when your repo accumulates a searchable decision history. Pairs well with planning skills when a spec precedes a formal ADR for a major fork.633installs145Nanobanana Ppt SkillsNanobanana Ppt Skills is an agent skill package for solo and indie builders who need presentation decks without spending hours in slide tools. It combines document analysis with AI-driven slide structure and styled imagery so you can go from specs, notes, or reports to a coherent deck faster. Install it when you are preparing investor updates, launch narratives, internal roadmaps, or training materials and want the agent to follow patterns from the NanoBanana-PPT-Skills project. The skill is intentionally narrow: it shines when the job is explicitly PPT generation with analyzed source content, not when you only need bullet outlines in chat. Treat outputs as drafts—verify facts, branding, and accessibility before sharing externally. It pairs well with content and launch workflows where a visual deck is the deliverable, while deeper market validation or live A/B testing still belongs in other phases of your journey.633installs146Antigravity WorkflowsAntigravity Workflows is an agent skill for solo and indie builders who use the Antigravity skill ecosystem and need a guided orchestration layer instead of ad-hoc skill hopping. Install it when the goal spans several capabilities—shipping an MVP, running an authorized security audit, building an AI agent, or executing browser QA—and you want a repeatable execution contract: confirm scope, pick the matching workflow, run steps in order, validate before continuing, and leave an audit trail of artifacts. Each step maps to a tangible output such as a scope document, implementation notes, test triage, or rollout checklist, which keeps Codex, Claude Code, or Cursor sessions from drifting. Safety rules require user approval for destructive work and explicit authorization before security testing. It fits small teams but is written for one person wearing product, build, and ship hats who needs dependable multi-skill choreography.631installs147Data ScientistData Scientist is an agent skill that casts your coding assistant as a senior data scientist for advanced analytics, machine learning, and statistical modeling aimed at solo and indie builders who cannot staff a full analytics team. It is meant for tasks where you need structured methodology—not ad-hoc guesses—across descriptive and inferential statistics, experiment design, predictive modeling, and visualization that supports decisions. The skill tells the agent to clarify goals, constraints, and required inputs up front, then apply domain best practices with actionable steps and outcome verification. It fits when you are exploring data to validate an idea, building model-backed features in your product, or compounding growth with measurable experiments. It is not a hosted notebook, MCP connector, or AutoML platform; it is procedural expertise packaged for Claude Code, Cursor, Codex, and similar agents. Pair it with your repo’s data stack and security review before promoting models to production.629installs148File UploadsFile Uploads is an agent skill for solo builders adding storage to SaaS or API products. It walks through S3 and Cloudflare R2, presigned URL flows, multipart uploads, and image optimization while keeping the request path non-blocking. Security is treated as mandatory: client-supplied extensions and headers are untrusted, with magic-byte checks recommended to stop renamed executables. The skill frames the agent as a file upload specialist—performance and safety over quick hacks. Use when your agent is implementing avatars, documents, exports, or media pipelines and you need consistent guidance on streaming, validation order, and cloud-native upload patterns rather than ad-hoc multer-only tutorials.628installs149Marketing Psychologymarketing-psychology trains the agent to act as a marketing psychology operator: define the target behavior and funnel stage, shortlist mental models that map to that action, score them with the Psychological Leverage & Feasibility Score, and deliver only the top three to five with ethical guardrails and test ideas. Solo builders use it when landing page copy stalls, onboarding drops, or pricing pages confuse—without importing manipulation tactics or endless theory lists. The skill emphasizes clarity, friction reduction, and better decisions rather than dark patterns. It spans validate when scoping offers and pricing psychology, launch when distribution assets must persuade, and grow when lifecycle and content need repeatable behavioral lifts. Writers should treat outputs as hypotheses to A/B test, aligned with the skill’s feasibility scoring so small teams do not over-invest in clever but hard-to-ship tactics.628installs150Writing PlansWriting Plans is a Superpowers-style community skill for solo builders who have a spec or multi-step requirements list and need a exhaustive implementation plan before coding. The agent writes for a skilled engineer with almost no knowledge of your repo, toolset, or test design—breaking work into 2–5 minute steps such as write failing test, run failure, minimal pass, re-run, commit. Every plan opens with a fixed markdown header naming the goal, architecture notes, and the required executing-plans sub-skill so implementation stays mechanical instead of improvisational. It belongs after brainstorming (often in an isolated worktree) when you are ready to translate decisions into ordered tasks covering code, testing, and docs. Risk is marked critical because a thin plan propagates bad assumptions across autonomous execution. Use it to de-risk Build delivery and Ship testing discipline; skip only when a dated plan already exists and execution has not diverged from it.624installs151Parallel Agentsparallel-agents teaches solo builders how to coordinate specialized agents through Claude Code’s native agent system instead of bolting on external orchestration scripts. The skill contrasts orchestration-friendly work—comprehensive architecture and security reviews, performance plus quality passes, and features that touch backend APIs, frontend UI, and data layers—with cases where a single generalist agent is faster and clearer. It documents invocation patterns from one-shot specialist calls to ordered chains, including passing findings from one agent into the next and resuming interrupted work. For indie builders shipping with Claude Code, Codex, or Cursor-style agent modes, it is procedural knowledge for turning ad-hoc “ask another hat” prompts into repeatable multi-perspective workflows without leaving the host environment.623installs152Notebooklmnotebooklm is an agent skill package that wires your coding agent to Google NotebookLM through browser automation (Playwright/Patchright-style flows). Solo and indie builders use it when they want repeatable, scriptable access to notebooks and libraries—uploading or referencing sources, running grounded Q&A, and keeping session state across runs—without manually clicking through the web UI each time. The skill documents a hybrid authentication model: a persistent user_data_dir for stable browser fingerprinting combined with cookie injection from state.json, which addresses known limitations where session cookies fail to persist on disk. Setup expects a local Python virtual environment, a protected data/ directory for auth and notebook metadata, and careful handling of secrets outside version control. It fits early journey research when you are comparing ideas and evidence, and it remains useful later when you are turning specs, support logs, or marketing copy into notebook-backed references for your agent workflows.622installs153Prompt Libraryprompt-library is a journey-wide reference skill that packages reusable prompt templates for solo builders who depend on Claude Code, Cursor, Codex, and similar assistants. It organizes battle-tested patterns—especially role-based system prompts such as expert developer and senior code reviewer—so you stop reinventing instructions every session. Review-oriented templates spell out concrete steps: hunt bugs and edge cases, judge structure and naming, flag security concerns, and return feedback in a structured severity-oriented format. The skill is meant when someone needs ready-to-copy prompts, role framing, task-specific examples, or a starting point to improve their own prompting discipline. Because prompts are domain-agnostic, the same library supports implementation during Build, review before Ship, audience-facing copy during Launch and Grow, and research-style questioning during Idea—without tying you to one toolchain beyond a capable chat or agent client.622installs154Canvas DesignCanvas Design is listed in the Antigravity awesome-skills bundle for builders who want agent help on canvas-oriented UI and visual work. The Prism ingest for this entry currently surfaces primarily SIL Open Font License text for bundled Arsenal fonts, so the operational playbook steps are not visible in catalog metadata alone. Treat the skill as a design-and-frontend helper: install when you are implementing canvas UIs, compositing marketing visuals, or embedding OFL-licensed typography in a product surface. Solo builders should pull the full SKILL.md from the repo to see triggers, deliverables, and any enumerated design checklist before delegating creative decisions to the agent. Confidence is moderated because description and body were not fully ingested; tags reflect naming, collection context, and license bundle evidence.620installs155Stitch Ui DesignStitch UI Design is an agent skill that teaches solo and indie builders how to write effective prompts for Google Stitch, Google’s AI UI design tool. Instead of vague requests that yield generic layouts, the skill encodes specificity rules, style vocabulary, and screen-flow structure so generated interfaces match product intent. It is aimed at founders validating landing pages, scoping mobile apps, or mocking SaaS dashboards before implementation. Use it when you are in Google Stitch (or planning to export designs to code) and need repeatable prompt patterns rather than one-off chat creativity. The skill packages core principles in SKILL.md plus categorized examples and advanced production techniques, making it a procedural companion for design-to-code workflows. It does not replace a design system or component library, but it reduces iteration cycles and miscommunication between prompt author and Stitch output.617installs156Plan WritingPlan-writing is an agent skill (obra/superpowers lineage) for structured task planning when you are about to implement features, refactor, or any work that spans more than a single chat turn. Solo and indie builders use it to force clarity: small focused tasks, clear done criteria, dependency order, and a verification phase always last. Unlike boilerplate project plans, it forbids fixed templates and verbosity—each plan should stay on one page with actionable one-line items. The deliverable is a dynamically named markdown file at the repository root so the agent and you share the same checklist. It pairs naturally with brainstorming and spec approval upstream and hands off to coding, testing, and review downstream without nesting plans in hidden agent folders.615installs157Zapier Make Patternszapier-make-patterns helps non-developer-friendly solo founders and lean teams automate revenue and ops workflows without immediately writing a custom integration service. The skill states a clear platform split: Zapier favors breadth and straightforward zaps across thousands of apps, while Make favors visual branching and cost control via operations-based billing. It stresses operational hygiene—start simple, name automations clearly, test on real payloads, and watch error rates because unreliable zaps get disabled automatically at high failure ratios. For Prism’s audience, it is most valuable when you are connecting CRM, email, sheets, and payment tools during Build, then maintaining those flows during Grow lifecycle and Operate support. It is pattern guidance, not a live OAuth connector, so agents use it to draft scenarios and escalation paths when complexity or volume outgrows buttons-and-filters UIs.612installs158Ab Test SetupA/B Test Setup is a gated agent skill that walks solo builders through rigorous experiment design before writing code. It enforces a clear user problem, analytics access, and traffic estimates up front, then applies a hypothesis quality checklist so every test states evidence, one specific change, audience, direction, and measurable criteria. A hypothesis lock step requires explicit confirmation of audience, primary metric, expected direction, and minimum detectable effect—progress stops until the builder commits. The skill also mandates listing validity assumptions and warning when traffic, independence, or external campaigns would bias results. Use it when you are planning landing page, pricing, onboarding, or feature tests and want to avoid peeking and underpowered calls. It fits indie SaaS and mobile teams who run experiments without a dedicated data science function.611installs159Address Github CommentsAddress GitHub Comments is an agent skill that walks solo builders through PR feedback using the official GitHub CLI. It starts with authentication checks, then inspects comment threads on the active pull request, groups feedback into an actionable plan, and pauses for your prioritization when there are many open items. After you confirm scope, the agent applies targeted code changes and replies on the PR so reviewers know each thread was handled. The workflow is deliberately lightweight—no custom marketplace servers—making it ideal for indie teams who already ship with `gh` in CI or locally. It complements human review rather than replacing it, and it keeps responses tied to commits so audit trails stay clear. Use it whenever a reviewer leaves inline notes or issue-linked feedback you want resolved before merge without ad-hoc chat-only promises.611installs160Llm App Patternsllm-app-patterns is a reference skill for solo builders shipping LLM-native products who want opinionated structure instead of improvised prompt chains. It surfaces when you are designing retrieval-augmented assistants, wiring tools into agents, or standing up LLMOps visibility. The README anchors a classic RAG flow—ingest, chunk, embed, vector search, then generation with grounded context—and extends into ingestion code patterns such as ChunkingStrategy with fixed-size and related modes. Because it explicitly calls out monitoring and architecture tradeoffs, it remains relevant after the first prototype: you can revisit chunking and retrieval choices during Ship performance work or Grow analytics tuning. It reads as pattern catalog plus snippets rather than a single executable CLI, so agents use it to justify design decisions in plans and implementations. Intermediate-to-advanced builders benefit most when they already have a datastore and model provider in mind.610installs161Python ProPython Pro is an expert agent skill for indie builders who want production-minded Python rather than tutorial snippets. It applies when you are writing or reviewing Python 3.12+ codebases, designing async workflows, optimizing performance, or standing up services with current ecosystem tools like uv, ruff, pydantic, and FastAPI. The skill walks agents through confirming runtime and dependencies, selecting patterns that match constraints, implementing with modern quality tooling, and profiling hot paths. It deliberately avoids non-Python stacks and pure syntax drills so sessions stay focused on shippable backend and CLI work. Because the same rigor helps during implementation, pre-ship review, and operational tuning, treat it as a multi-phase companion across Build and Ship rather than a one-off snippet generator.609installs162Frontend Security Coderfrontend-security-coder is an agent skill that turns generic “make the frontend secure” requests into concrete client-side practices: cross-site scripting (XSS) prevention, output sanitization, safer DOM updates, and Content Security Policy (CSP) thinking. It is aimed at solo and indie builders shipping SaaS dashboards, marketing sites, or browser extensions who need implementation guidance while coding—not a substitute for a full penetration test or policy audit. Use it during frontend implementation when you are wiring forms, rendering user-generated content, or tightening headers before release. The skill clarifies goals and constraints, applies browser-focused best practices, and leaves verifiable steps you can check in devtools and staging. Pair it with automated tests and a dedicated security review pass on auth, payments, and admin surfaces. When detailed walkthroughs are required, it directs you to the bundled implementation playbook for expanded checklists and patterns.607installs163KaizenKaizen is a journey-wide agent skill that encodes continuous-improvement discipline for solo and indie builders shipping with AI coding tools. It is for anyone who wants steady code quality gains without big-bang refactors or perfectionism paralysis. Invoke it when you are implementing features, refactoring, making architecture calls, tightening error handling, or discussing process improvements with your agent. The skill frames quality as many small, verified improvements that compound, error-proofing by design, following what already works, and building only what is needed. It contrasts one massive change with incremental wins, an explicit three-pass refinement loop, and a rule to leave touched code better than you found it. It pairs naturally with planning and review rituals elsewhere in a stack, but stands alone as procedural knowledge your agent can apply whenever quality and prevention matter more than speed at any cost.607installs164Quant Analystquant-analyst is an agent skill for solo builders exploring algorithmic trading, portfolio tooling, or internal quant dashboards without hiring a desk quant. It steers the agent through data-quality-first workflows: clean and validate market inputs, implement vectorized strategy logic, and backtest with realistic transaction costs and slippage rather than fantasy fills. Risk-adjusted metrics—VaR, Sharpe, max drawdown—and portfolio optimization framing (Markowitz, Black-Litterman) appear alongside time-series forecasting and statistical arbitrage patterns such as pairs trading. The skill insists on out-of-sample testing to curb overfitting and on keeping research notebooks separate from production paths you might Operate later. Outputs include strategy implementations and backtest result summaries suitable for CLI scripts or API services. Invoke when your idea is validated enough to code but you need disciplined financial modeling guardrails; skip when the task is unrelated trading analytics. Community-sourced guidance—verify licensing and data vendor compliance before live capital.607installs165Azure FunctionsAzure Functions is an agent skill that encodes expert serverless patterns for solo and indie builders shipping on Microsoft Azure. It focuses on the modern isolated worker model for .NET, including Program.cs host setup, telemetry wiring, and dependency injection that avoids common pitfalls like socket exhaustion. The skill also covers Durable Functions for reliable orchestration across long-running steps, plus cold start and production practices that matter when you are paying per invocation and need predictable latency. Coverage spans .NET, Python, and Node.js so you can align triggers and bindings with the stack you already use in Claude Code, Cursor, or Codex. Use it while scaffolding new function apps or refactoring in-process models to isolated workers, before you wire CI/CD and monitoring in Ship and Operate.601installs166Cc Skill Frontend Patternscc-skill-frontend-patterns packages modern frontend development patterns for React, Next.js, state management, performance optimization, and UI best practices into agent-ready prose and code samples. Solo builders install it when they want consistent component architecture—composition instead of inheritance, compound components with shared context, and typed props—rather than one-off chat suggestions that drift from project conventions. The readme walks through concrete TypeScript examples such as composable Card layouts and Tabs providers, which agents can mirror when scaffolding features or refactoring legacy JSX. It suits intermediate builders who already run a web app repo and want faster, more uniform UI changes during the Build phase, with secondary value when reviewing UI quality before Ship. Risk is marked unknown in metadata, so treat outputs as patterns to adapt, not as automatic replacements for your design system.600installs167GraphqlGraphQL is an agent skill that teaches solo builders how to treat GraphQL as a typed contract: one endpoint, precise selections, and introspection—with guardrails so flexible queries do not take down your server. It walks schema-first design, resolver patterns, DataLoader batching, depth and complexity limits, fragments, specific mutations, and federation for distributed graphs, plus client integration with Apollo and urql. The framing matches 2025 practice: reach for GraphQL when relationships are messy and clients need different shapes, not for every CRUD surface where REST and HTTP caching are simpler. Indie developers shipping SaaS or agent backends use it while modeling APIs, reviewing resolver performance, or choosing between REST and GraphQL for a new service. It is procedural architecture knowledge from the vibeship-spawner-skills lineage (Apache 2.0), not a live schema generator or hosted gateway.599installs168Hubspot IntegrationHubSpot Integration is an agent skill for solo founders connecting a SaaS signup flow, product usage, or support touchpoints to HubSpot CRM without guessing OAuth scopes or association APIs. It emphasizes expert patterns: public-app OAuth with client ID, secret, and redirect URI; token handling after the authorize callback; reading and writing contacts and related CRM objects; linking records through associations; batch endpoints for sync jobs; and webhooks for near-real-time updates. Custom objects are covered when standard schemas are not enough. Examples skew toward the official Node and Python clients so your agent generates maintainable SDK code instead of raw fetch sprawl. Use during Build when CRM sync is a core integration; pair with your own env and consent UX before Ship security review.595installs169Slack Bot BuilderSlack Bot Builder is an agent skill for indie developers shipping internal tools, support bots, or workflow assistants inside Slack. It centers on Slack’s Bolt framework across Python, JavaScript, and Java so you do not reimplement verification, routing, and payload parsing by hand. Use it when you are starting a new Slack app, migrating off legacy Slack APIs, or hardening an integration for production. The skill walks foundational app setup (tokens, signing secret, adapters), rich UI with Block Kit and interactive components, slash commands and event subscriptions, multi-workspace OAuth installs, and Workflow Builder integration. It assumes you will store secrets in environment variables and follow Slack’s recommended security defaults rather than one-off HTTP handlers.595installs170Security Auditsecurity-audit is an Antigravity workflow bundle that turns scattered security skills into a solo-builder-friendly audit ritual for web applications, APIs, and supporting infrastructure. Instead of asking an agent to improvise OWASP coverage, you walk phases: reconnaissance to map scope and technologies, vulnerability scanning with static and dependency checks, then remediation-oriented follow-through implied by the bundle structure. It targets indie teams without a dedicated AppSec function who still need credible pre-ship assurance, API hardening, or compliance-oriented assessment narratives. Invoke it when you have a defined target environment and want explicit skill names—scanning-tools, shodan-reconnaissance, vulnerability-scanner—in sequence rather than one monolithic prompt. It complements single-purpose checker skills by coordinating when each specialist skill should load.594installs171React Best Practicesreact-best-practices packages Vercel’s maintained performance guide for React and Next.js so your agent does not guess optimization order. Solo builders invoke it when creating components or pages, choosing client vs server data fetching, or cleaning up waterfalls and bundle bloat before users feel latency. The taxonomy ranks impact from CRITICAL waterfall and bundle work through server, client fetch, re-renders, rendering, JS micro-optimizations, and advanced patterns—giving you a checklist-driven refactor path instead of scattered blog advice. It is equally useful during Build for greenfield code and during Ship when you review or refactor for production. Because rules are prefixed by category, you can scope an agent pass to the highest-leverage fixes first. Treat it as editorial standards, not a test runner; you still validate with profiling and real user metrics after changes.593installs172Analytics TrackingAnalytics Tracking is an agent skill for solo builders who need instrumentation that actually supports decisions across marketing, product, and growth. It treats analytics as measurement design: you do not add events because a dashboard looked empty, and you do not trust GA4 totals until integrity checks pass. Every engagement starts with Phase 0 and a Measurement Readiness & Signal Quality Index on a 0–100 scale, weighted toward decision alignment, event model clarity, data accuracy, conversion definitions, and attribution context. That diagnostic framing prevents false confidence from broken pixels, duplicate events, or vague conversions. Use it when launching new funnels, refactoring tracking after a rebrand, or when growth experiments disagree with what your tools report. It complements implementation work in build and launch phases but lives primarily in grow/analytics where you validate whether numbers are decision-ready.592installs173Algolia SearchAlgolia Search is an agent skill that packages opinionated patterns for adding fast, facet-friendly product or content search to modern React and Next.js applications. Solo builders use it when they need InstantSearch wired correctly—search-only keys in the browser, lite client imports, and hook-based widgets—without re-reading Algolia docs for every new side project. The skill covers type-ahead UX, hit templates, refinement lists, and pagination, and it nudges relevance tuning and indexing strategy as part of the same integration story so search quality is not an afterthought. It assumes environment-driven credentials and a named index such as products. Ideal for SaaS dashboards, ecommerce catalogs, and content sites where findability directly affects conversion and support load during Build.590installs174Content MarketerContent Marketer is an agent skill that positions your coding agent as a senior content marketing strategist for solo builders shipping SaaS and software products. It is meant when you need guidance on AI-assisted drafting, omnichannel planning, SEO alignment, and measurable content performance—not when the task is unrelated to marketing content. The workflow starts by clarifying goals, constraints, and inputs, then applies best practices with verifiable steps rather than generic advice. Capabilities emphasize integrating AI writing tools, building search-oriented assets, and tying content initiatives to engagement, leads, and revenue. Because it is playbook-oriented and references an implementation markdown for depth, treat it as strategic and procedural support you steer with your product context. Use alongside analytics or distribution skills once drafts exist. Skip when you only need a single social post or pure technical documentation with no marketing angle.590installs175Webapp TestingWebapp-testing is an agent skill aimed at solo and indie builders who need repeatable confidence that their web UI still works after changes. In the Prism catalog it sits under Ship → Testing because its main job is exercising real browser sessions against your app—not inventing features or writing launch copy. When SKILL.md body is not bundled in the ingest snapshot, the slug and collection naming still signal a procedural playbook for driving a web application through critical paths, capturing failures, and feeding results back into your agent loop. That pattern matters for one-person teams who cannot afford dedicated QA but still ship customer-facing SaaS, internal tools, or landing flows. Install it when you want testing steps encoded as skill knowledge so every session follows the same ritual instead of improvising prompts. Treat outputs as inputs to fix-and-retest cycles in Build and Ship, and re-run after perf or security passes when UI behavior might have shifted.590installs176Skill DeveloperSkill Developer surfaces advanced and forward-looking topics for people maintaining a structured skill ecosystem—not day-one SKILL.md writing, but how routing, enforcement, and dependencies might evolve. It documents today's limitation that skill-rules.json changes need a Claude Code restart, and proposes watching the file for hot-reload, invalidating compiled regex caches, and notifying users on reload. Dependency configuration would let advanced skills declare prerequisite packages and load order for complex workflows. Conditional enforcement sketches default suggest with block in production or CI and relaxed suggest in development. Solo builders running antigravity-style monorepos use this as a roadmap when governance, CI gates, or skill chains outgrow ad hoc folders. Pair with writing-skills for content quality and with your own implementation work; this skill describes concepts and JSON shapes rather than shipping a finished hot-reload daemon.588installs177Writing SkillsWriting Skills teaches solo builders how to create agent skills that actually get discovered and used. It stresses that SKILL.md competes with system prompts, history, and other skills once loaded, while only name and description sit in startup metadata until relevance triggers a read. The guide pushes authors to assume strong baseline model knowledge, delete explanatory fluff, and structure procedures so additional files load progressively. That matters for indie teams shipping many small skills for Claude Code, Cursor, or Codex without blowing context on every turn. Use it before your first SKILL.md, when refactoring a bloated skill, or when agents ignore a capability because the description never matched invoke triggers. It complements testing skills in real tasks and reviewing security before publishing to a shared repo or marketplace.588installs178Algorithmic ArtAlgorithmic-art is an agent skill in the antigravity-awesome-skills collection oriented toward procedural and generative artwork—patterns an agent follows to create code-driven or rule-based visuals instead of static mockups alone. Prism lists it for solo builders who want distinctive hero graphics, demo backdrops, or creative coding experiments while shipping a product; the ingested README in catalog is license-forward, so invocation should lean on the skill name and repo conventions for actual generation steps. Treat it as a generative-media companion during Build when you need canvas, shader, or plot-style output, and again in Validate or Launch when a quick visual prototype or distinctive marketing asset saves a design hire. Confidence is moderated because full SKILL.md procedures were not present in the ingest snippet—verify triggers inside the repo before production use.586installs179Neon PostgresNeon Postgres is an agent skill that teaches expert patterns for Neon’s serverless PostgreSQL: branching, PgBouncer pooling, and clean integration with Prisma or Drizzle. Solo builders shipping a SaaS or API often hit migration failures when every query goes through a pooler, or they exhaust connections in serverless deploys—this skill encodes the two-connection-string model and schema wiring so agents configure .env, prisma/schema.prisma, and a safe PrismaClient singleton without guesswork. It is aimed at indie developers using Claude Code, Cursor, or Codex during backend implementation, when you are choosing hosted Postgres and need production-ready defaults rather than a local-only tutorial. Use it when you are adding users, auth tables, or app data on Neon and want repeatable ORM setup that matches how Neon expects pooled versus direct traffic.586installs180Mcp BuilderMCP Builder is an agent skill aimed at solo builders who need a custom Model Context Protocol server so Claude Code, Cursor, or similar clients can call their APIs, databases, or internal scripts safely. Prism’s ingested readme is dominated by Apache 2.0 license text, so treat on-disk SKILL.md in the source repo as the source of truth for step order and tool definitions. Typical use is during Build when you have a working API or script and want structured tool schemas, transport config, and packaging—not when you only need a one-off shell script. Scope is phase-specific to Build → agent-tooling because MCP work is integration-heavy and rarely spans validate landing pages or launch SEO. After install, have your agent read the full skill body before generating server code.584installs181Rag Implementationrag-implementation is a granular workflow bundle that sequences how a solo builder stands up retrieval-augmented generation end to end. It starts with requirements—use case, data sources, accuracy, latency, and evaluation metrics—then moves through embedding model selection with domain relevance and cost/latency tradeoffs, vector database configuration, chunking strategy, and retrieval optimization. The readme names concrete companion skills (ai-product, rag-engineer, embedding-strategies) and supplies copy-paste @-invocation prompts so your agent does not skip analysis before picking models. Use it when you are building agent tools, internal doc Q&A, or customer-facing semantic search rather than bolting a single prompt onto raw context windows. The workflow spans Validate-style scoping in early phases and Build integrations for stores and pipelines, with Ship concerns implied via latency and accuracy gates. It complements narrow embedding or DB skills by holding the full delivery arc in one procedural package dated 2026-02-27 in the source metadata.584installs182Reverse EngineerReverse Engineer is an agent skill for solo and indie builders who must understand closed-source or suspicious binaries without a full RE team. It frames common reverse-engineering scripting environments and a structured methodology from initial file identification through metadata extraction and packer detection, so your agent does not jump straight into disassembly without context. The skill fits security reviews, CTF prep, compatibility research, and incident triage when you already know the task is in-scope for binary analysis. It explicitly defers to a separate implementation playbook when you need walkthrough-level detail. Because the source metadata marks offensive risk, treat installs as high-trust: pair the skill with your own legal boundaries and the Security Audits panel on this catalog page rather than assuming safe defaults.584installs183Marketing IdeasMarketing Ideas is an agent skill for solo and indie SaaS builders who need a strategist, not another brainstorm doc. It treats marketing as a prioritization problem: you establish product type, ideal customer, lifecycle stage, budget, team constraints, and whether you care about traffic, leads, revenue, or retention. The agent shortlists six to ten relevant plays from a fixed library of 140 proven ideas, drops obvious mismatches, and scores survivors with the Marketing Feasibility Score so recommendations stay actionable under real constraints. Output is deliberately narrow—typically three to five ideas with operational first steps, measurable success criteria, and honest execution risk. Use it when launch and growth channels feel noisy, when you cannot afford to test everything, or when you want an agent to act as a filter instead of dumping tactics. Pair it with content execution or analytics skills once you have a chosen channel.581installs184Viral Generator Builderviral-generator-builder teaches solo builders how to architect generator-style web experiences—quizzes, name tools, avatars, calculators—that people voluntarily forward to friends. It emphasizes psychology over gimmicks: identity moments, shareable outputs, and differentiation between one-off utilities and spread-first products. The skill spans planning what result is worth screenshotting, structuring the generator flow, and tuning social sharing—not generic landing copy. It pairs with Validate prototypes and Launch distribution pushes when you are betting on organic reach instead of paid ads alone. Intermediate builders shipping content-led or lightweight SaaS surfaces get the most value; enterprise B2B dashboards without a consumer share loop are a poor fit.580installs185Plaid FintechPlaid Fintech is an integration skill for builders shipping personal finance, lending, or cash-flow products that need bank linking without reinventing Plaid’s docs. It encodes expert patterns for creating short-lived link tokens, exchanging public tokens for durable access tokens, and structuring server endpoints with the official Node Plaid client. Coverage includes transactions synchronization, identity verification, Auth for ACH funding, balance checks, and webhook-driven updates when users change bank passwords or institutions. Solo founders using Claude Code or Cursor can paste these patterns into a SaaS backend, set PLAID_CLIENT_ID, PLAID_SECRET, and PLAID_ENV correctly, and avoid common footguns like treating link tokens as reusable. The skill emphasizes compliance-aware habits appropriate to fintech, though you remain responsible for your own regulatory scope. Use during backend build when MVP scope includes read-only aggregation or money movement—not for marketing site copy or generic SEO.576installs186Behavioral ModesBehavioral-modes is a journey-wide agent skill that tells your AI assistant which operating posture to adopt before it dives into work. Solo builders juggling idea, build, and ship phases often get mismatched output—brainstorm sessions that prematurely write code, or implementations that over-explain like a course. This skill names seven modes with explicit when-to-use triggers and expected behaviors, from divergent brainstorming with pros/cons options through fast implement passes tied to clean-code discipline, plus debug, review, teach, ship, and orchestrate variants. It is procedural knowledge for Claude Code and similar agents, not an MCP server or runtime switch you install in your app. Use it whenever task type changes mid-session so the agent’s questions, verbosity, and artifacts stay aligned with whether you are exploring, executing, or stabilizing production.575installs187Startup AnalystStartup Analyst is an agent skill that acts as an expert business analyst for early-stage companies from pre-seed through Series A. Solo and indie founders install it when they need rigorous but practical help with market sizing, financial modeling, competitive strategy, and business planning without hiring a full-time analyst. The skill emphasizes actionable steps, validation of assumptions, and outcomes that support fundraising and strategic decisions rather than generic consulting prose. Invoke it when you are working through analyst workflows, need checklists and best practices for startup analysis, or want guidance aligned to entrepreneur and angel/seed investor expectations. It tells you to clarify goals, constraints, and inputs first, apply relevant frameworks, and verify results; for extended examples it points to the implementation playbook. It is a poor fit when the task is unrelated to startup business analysis or when you need a different domain tool entirely.575installs188Test Fixingtest-fixing is an agent skill that turns chaotic test failures into an ordered repair queue. It starts with a full suite run (documented as `make test`), classifies failures by error family and shared files, and fixes groups from highest impact downward while respecting dependency order—imports and fixtures before business assertions. Solo builders invoke it when someone says the suite is red, CI is blocked, or implementation just landed and green tests are required. It spans late Build when tests catch regressions and Ship when release gates depend on CI. The skill does not replace writing new tests; it stabilizes existing ones after churn. Keep your project’s real test command handy if it differs from `make test`, and rerun the suite after each group to avoid fix-one-break-another loops.574installs189Outlook Calendar AutomationOutlook Calendar Automation is an agent skill that drives Microsoft Outlook Calendar through Composio’s Outlook toolkit exposed as Rube MCP. Solo builders and small teams use it when they want scheduling, invitations, attendee handling, and meeting-time discovery inside Claude Code, Cursor, or similar clients instead of copying Graph API snippets into chat. The workflow assumes RUBE_SEARCH_TOOLS is available, connections are verified with RUBE_MANAGE_CONNECTIONS for the outlook toolkit, and Microsoft OAuth is completed before any OUTLOOK_* calls. Documented core path covers listing calendars optionally and creating events with required subject and start_datetime fields. Because operations run against a live mailbox and community-sourced skill metadata marks risk as critical, treat credentials and calendar side effects as production-grade: confirm scopes, test on a non-critical calendar first, and read the Security Audits panel on this Prism page before trusting automated scheduling in customer-facing workflows.569installs190Paid Adspaid-ads is a community performance-marketing skill that walks a solo builder through creating, optimizing, and scaling paid campaigns as if an expert marketer had access to your ad accounts. Before any recommendations, it forces clarity on campaign goals (awareness through app installs), target CPA or ROAS, budget, product offer, landing URL, ideal customer, and whether pixels or historical conversion data exist. The embedded platform selection guide highlights when Google Ads fits high-intent search and how to weigh other channels against constraints like geography or compliance. Use it when you are ready to spend money on distribution—not when you are still validating whether anyone wants the product. The skill is advisory and process-heavy; you still connect real ad platforms and upload creatives yourself. It pairs naturally with landing-page and analytics skills once tracking is live.569installs191Pptx OfficialPPTX Official is an agent skill for solo builders who treat slides as real artifacts—investor decks, launch narratives, training, or client deliverables—not opaque binary blobs. It explains that .pptx files are ZIP archives of XML and resources, and routes tasks to the right depth: quick markdown conversion with markitdown when you only need text, versus unpacking with the bundled OOXML scripts when you must touch speaker notes, slide masters, animations, or formatting. For one-person shops without a deck specialist, the skill keeps agents from hallucinating PowerPoint APIs and instead using documented Python paths. Use it when generating new presentations, patching existing slide content, or auditing what is actually inside a file before a validate or launch milestone.569installs192Instagram AutomationInstagram Automation via Rube MCP is an agent skill package that teaches your Claude Code, Cursor, or Codex session how to run Composio Instagram tools through the Rube endpoint at https://rube.app/mcp. It is aimed at solo and indie builders who ship content-led products and want repeatable, tool-driven posting instead of one-off chat guesses about Graph API steps. The skill documents setup (verify RUBE_SEARCH_TOOLS, connect instagram, complete OAuth), then walks core workflows: single post creation with container polling, multi-item carousels, comment handling, insights, and publishing limit checks. It stresses operational guardrails—search tools for current schemas, never publish before containers finish processing, and recognize that personal Instagram accounts are unsupported. Use it when you already have media URLs and captions ready and need your agent to execute the correct INSTAGRAM_* sequence safely during growth and launch distribution work.566installs193Remotion Best PracticesRemotion Best Practices (3D) is an agent skill for solo builders shipping programmatic video with Remotion plus React Three Fiber. It encodes the non-obvious contract between Three.js scenes and Remotion’s frame-based renderer: install `@remotion/three`, wrap scenes in `ThreeCanvas` with explicit dimensions from `useVideoConfig`, and drive every visible change from `useCurrentFrame()` so headless renders match preview. The skill points agents away from R3F habits like unsynchronized `useFrame()` loops that cause flicker across frames. For indie creators building product demos, motion graphics, or social clips as code, this reduces painful render-debug cycles. Invoke when adding 3D layers to a Remotion composition or when an agent suggests standard Three.js animation patterns that violate Remotion’s determinism requirements.564installs194Loki ModeLoki-mode packages a ready-to-adapt GitHub Actions job that invokes Claude Code Review on every relevant pull request. Solo and indie builders who ship through GitHub can wire OAuth via CLAUDE_CODE_OAUTH_TOKEN, drop the workflow into .github/workflows, and get consistent review commentary without manually pasting diffs into chat. The default prompt anchors context with REPO and PR NUMBER, then asks for constructive feedback across code quality, defect risk, performance, security, and tests—aligned with how small teams actually gate merges. Optional comments show how to limit runs to specific paths or external or first-time contributors when review budget matters. Permissions are scoped to read repository and PR metadata while allowing OIDC for the action. It is an integration pattern, not a local SKILL.md ritual: you customize triggers, secrets, and the prompt block to match your monorepo layout and severity bar.562installs195Tiktok AutomationTikTok Automation is an integration skill for solo builders and creators who want their coding agent to drive TikTok through Rube MCP (Composio) rather than clicking through the mobile app for every post. It assumes RUBE_SEARCH_TOOLS is available so schemas stay current, and an ACTIVE TikTok connection after OAuth via RUBE_MANAGE_CONNECTIONS. Core flows cover uploading one or more videos, polling publish status, publishing when processing completes, and related profile or content operations surfaced by the toolkit search. It fits launch-phase distribution for indie products, courses, or personal brands where short video is part of the channel mix—not a replacement for creative strategy, hooks, or compliance with TikTok’s policies. Always search tools before invoking because Composio action names and parameters change. Treat the documented critical risk tier seriously: limit to accounts you own, understand what publish permissions grant, and do not point automation at client assets without explicit consent.561installs196Fastapi Profastapi-pro is an agent skill that positions the coding agent as a FastAPI specialist for async-first HTTP and WebSocket APIs. Solo builders use it when standing up SaaS backends, agent tool servers, or microservices where OpenAPI contracts, typed request models, and SQLAlchemy 2.0 persistence must align with current Python practice. The skill emphasizes Pydantic V2 serialization, dependency injection, background work, and scalable service layout rather than one-off scripts. Workflow starts by clarifying goals and constraints, then applying checklists and verification steps; heavier recipes live in the bundled implementation playbook. It fits Claude Code or Cursor sessions already committed to Python 3.10+ and async drivers. Skip when the stack is Django-only, serverless functions without a long-lived app, or non-Python runtimes. After endpoints exist, chain into testing and security skills before ship. Review Security Audits on Prism for community-sourced skill packs.560installs197CrewaiCrewAI is an agent skill that teaches solo and indie builders how to structure collaborative LLM teams using CrewAI’s role-based model. The skill positions you as a multi-agent architect: you define agents with explicit roles and goals, break work into tasks with expected outputs, assemble crews, and choose orchestration patterns such as sequential, hierarchical, or parallel execution. It also covers memory setup, attaching tools, and using Flows when linear task chains are not enough. The content is aimed at builders who already grasp delegation concepts and want production-style agent collaboration rather than a single monolithic prompt. Use it while designing backends or internal automations where several specialized agents hand off work. It does not replace infrastructure deployment or security review; it accelerates the design and implementation of agent graphs in Python once you have API access and the crewai dependency available.559installs198Data EngineerData Engineer is an agent skill that positions your coding agent as a senior data engineer for scalable batch and streaming systems, warehouses, and lakehouse designs. Sickn33’s community skill tells the agent when to engage—pipeline design, warehouse or lakehouse builds, and quality, lineage, or governance work—and when to stop: exploratory analysis only, ML without ingestion paths, or environments without reachable sources and sinks. Instructions walk through defining sources, SLAs, and contracts, picking storage and orchestration, implementing ingestion and transformation with validation, then monitoring quality, spend, and reliability. Solo builders standing up SaaS analytics, event pipelines, or internal metrics stacks can use it to avoid hand-wavy “just use Airflow” advice and instead get structured architecture and operational guardrails. It complements application backend skills by specializing in the data plane rather than HTTP handlers alone.558installs199Threejs SkillsThree.js Skills is an agent skill for solo builders adding 3D graphics to web products—landing heroes, product configurators, data visualizations, or lightweight games—without reverse-engineering boilerplate on every task. It systematizes modern Three.js (r183+) setup: import maps or bundler imports, scene/camera/renderer initialization, controls, and common effect patterns when users ask for rotating models, explorable scenes, or WebGL visuals. Use it in the Build phase on frontend workstreams where canvas performance and module paths trip up agents. It complements plain React or static CSS skills by focusing on WebGL lifecycle, addons, and interactive 3D UX rather than generic layout—ideal when distribution and SEO come later in Launch.558installs200Aws Skillsaws-skills is a lightweight agent skill that steers Claude Code, Cursor, Codex, and similar tools through Amazon Web Services development with emphasis on infrastructure automation and repeatable cloud architecture patterns. Solo and indie builders use it when a task touches VPCs, compute, storage, IAM-shaped design, or deployment automation and they want procedural context instead of improvising from chat memory. The bundled SKILL.md is intentionally high-level: it names when to invoke the skill, points to the upstream GitHub project for concrete recipes, and reinforces boundaries—validate in your own account, test changes, and escalate when credentials or blast radius are unclear. It fits multi-phase work because the same AWS literacy helps while wiring integrations during Build, hardening launch paths during Ship, and evolving stacks during Operate, even though Prism shelves it under Build → integrations as the first obvious home.556installs201Performance Engineerperformance-engineer is an agent skill that acts like a staff performance consultant for solo builders running real services. It starts by locking performance goals, user impact, and baseline metrics, then uses traces, profiles, and load tests to find bottlenecks instead of guessing. You get optimization proposals with expected impact and explicit tradeoffs, followed by verification steps and regression guardrails. The skill refuses shallow summaries when you lack observability data and warns against hammering production without approval. It fits indie teams shipping APIs, SaaS dashboards, or agent backends where latency and cost silently eat margin. Use it when performance is a goal—not for feature-only work with no measurable targets.555installs202LangfuseLangfuse is an agent skill that positions you as an LLM observability architect for solo-built products that already call models in production. It covers tracing architecture, prompt versioning, evaluations, datasets, cost optimization, and quality monitoring—framed for Python or TypeScript apps wired through LangChain, LlamaIndex, or direct OpenAI APIs. Install it when debugging flaky agent loops, proving prompt changes did not regress quality, or explaining latency and spend to yourself or a tiny team. The skill emphasizes traces and spans as first-class signals, not afterthought logs. It does not replace your hosting or auth layer; it complements ship-time testing by giving continuous visibility in Operate. Expect integration guidance and operational practices rather than a greenfield tutorial on building your first chat UI.554installs203Mobile Developermobile-developer is an agent skill for solo and indie builders who need expert guidance while building React Native, Flutter, or native iOS and Android applications. It treats mobile as a first-class build problem: you clarify goals and constraints, then apply architecture patterns suited to cross-platform reuse, native modules, offline synchronization, and store readiness. The skill spans high-signal stacks called out in the playbook—React Native with the New Architecture, Flutter with current Dart features, Expo development builds, web-to-mobile transitions via Capacitor, and related .NET mobile options—so you are not locked to a single framework fad. It is meant for active implementation and review during the Build phase, when navigation, rendering performance, and platform APIs matter, not for unrelated backend-only tasks. Use it when you want actionable steps, validation, and pointers to a fuller implementation playbook instead of generic “make an app” chat advice.551installs204Pricing StrategyPricing-strategy is a consultation-style agent skill that helps solo and indie builders answer how to charge before they wire Stripe or rewrite a marketing site. It walks through required context—business model, competitive alternatives, current ARPU or churn if any, and whether you are optimizing growth versus margin—then applies pricing fundamentals around packaging, the value metric customers actually buy, and the price points that match willingness to pay. The workflow emphasizes capturing value without eroding conversion or trust, including how to plan tier moves upmarket or downmarket. It explicitly does not implement pricing pages, experiments, or billing code, which keeps the skill in strategic validate and grow conversations rather than build-time UI work. Use it when you have a defined offer and comparables; skip it when you only need HTML for a pricing table or server-side entitlement logic.549installs205Social ContentSocial Content is an agent skill that acts as a social media strategist for solo and indie builders who need consistent, on-brand posts without hiring an agency. Before generating copy, it walks you through objectives (awareness, leads, traffic, community), audience and platform fit, tone and taboo topics, and what you can realistically produce or repurpose from blogs, podcasts, or video. It then applies network-specific playbooks—formats, hooks, posting cadence, and engagement patterns—for professional and consumer channels alike. The workflow emphasizes measurable actions (what you want followers to do) and sustainable calendars rather than viral one-offs. It fits builders shipping SaaS, content products, or ecommerce who are in distribution and lifecycle phases but still own their own marketing. Use it when you have a message and channels in mind but need structured ideation, drafts, and scheduling-ready packages aligned to your brand voice.547installs206Avalonia Layout ZafiroAvalonia Layout Zafiro is an agent skill that steers solo builders toward maintainable Avalonia UI using Zafiro-style layout and interaction patterns. When you bind desktop or cross-platform clients, XAML often accumulates opaque converters and code-behind; this skill pushes UI concerns into reusable behaviors, keeps ViewModels supplying display-ready values, and reserves converters for rare visual-only reuse. It fits indie developers shipping .NET Avalonia apps who want agents to generate views consistent with their stack. Invoke during feature UI work, refactors of messy bindings, or when onboarding an agent to an existing Zafiro codebase. The content is prescriptive patterns rather than a full component catalog, so pair it with your project’s design tokens and navigation shell.544installs207Cc Skill Strategic Compactcc-skill-strategic-compact is a journey-wide productivity skill from the everything-claude-code lineage that helps solo builders preserve useful agent context by compacting at deliberate milestones rather than letting auto-compact fire mid-task. It explains why manual strategic compaction beats arbitrary truncation: compact after exploration before implementation, and after finishing one milestone before starting the next. The skill ships hook guidance—PreToolUse on Edit|Write calling a suggest-compact shell script—and criteria such as extended session duration, large tool-call counts, and transitions from research to coding. Use it whenever you run multi-hour Claude Code sessions on build, ship, or operate tasks. It does not replace environment-specific testing or expert review; stop and clarify if hook permissions or success criteria are unclear. Ideal for indie developers who treat context as a scarce resource across the whole shipping journey.543installs208Personal Tool BuilderPersonal Tool Builder is a journey-wide agent skill for solo makers who treat their own workflows as the first customer. It encodes a personal-tool architect mindset: identify a nagging problem, ship a rough CLI, script, or local-first app, use it daily, and let demand from your own pain drive what merits polish or wider release. The skill spans rapid prototyping, automation, local-first design, and the path from weekend utility to something thousands might adopt—without premature enterprise process. Prism lists elevated source risk on this package; treat installs like any third-party skill and read audits before granting broad permissions. It fits whenever you are exploring what to build, scoping a MVP, implementing a helper, or deciding whether a hack deserves product investment. It is intentionally not a corporate platform playbook; it optimizes for one builder with perfect self-PMF at user count one.542installs209Backend Development Feature DevelopmentBackend Development Feature Development is a workflow skill for solo builders and small teams who need more than a one-shot codegen prompt when shipping a backend capability. It orchestrates end-to-end delivery: clarifying requirements, aligning architecture across services, guiding implementation, testing, and production deployment with modern practices like feature flags and gradual rollouts. Invoke it when a feature touches multiple layers, needs coordinated rollout and monitoring, or must align scope and risks before code lands. Skip it for isolated backend fixes or when you only need a single specialist task without deployment coordination. The skill emphasizes phase-to-phase consistency so agents do not lose context between planning and ship.540installs210Pentest ChecklistPentest Checklist is a Security-category agent skill that packages the full authorized penetration-test lifecycle into checkbox-driven phases—scoping objectives, aligning legal authorization, preparing the environment, executing under monitoring, and driving remediation with verification. Solo builders selling B2B SaaS or handling sensitive data often need a pentest gate before launch or enterprise deals but lack an internal AppSec function; this skill keeps planning and follow-up exhaustive so engagements do not collapse into a vague “run a scanner” task. It explicitly requires authorized use only and lists prerequisites like scope documents and stakeholder contacts. Intermediate complexity: you must bring contracts, environment truth, and budget reality—the skill does not perform attacks itself. Pair it with Ship security work first; reuse the remediation section when Operate findings reappear in production monitoring.539installs211Startup Business Analyst Business CaseStartup Business Analyst Business Case is a generator-style agent skill that walks solo founders through a complete investor-ready business case: executive summary, problem and market opportunity, solution and product, competitive landscape, financial projections, go-to-market, team, risks, and funding ask with use of proceeds. It is built for indie builders who must align narrative and numbers before pitching angels, accelerators, or strategic partners—not after scrambling slides. The workflow starts by clarifying goals, constraints, and required inputs, then applies structured steps Claude follows when the command is invoked, with an optional deeper playbook for implementation examples. Use it when you are scoping a venture, updating a deck narrative, or pressure-testing whether the opportunity story holds together. Skip it when the task is unrelated to business-case work or when you need legal incorporation, cap-table modeling, or live market data APIs instead of guided document generation. Pair it with research skills upstream and planning skills downstream once the case is approved.537installs212Api Documenterapi-documenter is an agent skill for solo and indie builders who need professional API documentation without hiring a technical writer. It guides you from audience and scope through OpenAPI 3.1+ specs, worked examples, authentication narratives, and interactive reference experiences that reduce time-to-first-successful-call. Use it when you are creating or refreshing specs, building a developer portal, improving discoverability of endpoints, or generating SDKs and snippets from a single source of truth. Skip it for informal internal notes, backend-only work with no public contract, or tasks with no API surface to describe. The workflow emphasizes validation against tests, clear versioning, and ongoing maintenance so docs stay trustworthy as the product ships and grows.535installs213PostgresqlPostgreSQL is an agent skill that walks solo builders through PostgreSQL-native table design instead of generic ER diagrams that ignore Postgres strengths. It tells you when to apply the skill—new schemas, type and constraint choices, index and partition planning, RLS—and when to stop, such as non-Postgres engines or pure query tuning without structural changes. Instructions start from real access patterns and scale targets (row counts, QPS, retention), then enforce invariants with constraints, align indexes to queries you can validate with `EXPLAIN`, and introduce partitioning or row-level security when scale or tenancy demands it. The tone matches experienced backend practice: identity keys over random UUIDs unless you need opaque global IDs, normalization before opportunistic denormalization, and migration-first safety on production. Use it while implementing SaaS or API backends where Postgres is the system of record and you want your coding agent to produce DDL and review checklists that survive growth.535installs214Cloud ArchitectCloud Architect is a community-sourced agent skill that acts as a multi-cloud design partner for solo builders who must pick AWS, Azure, or GCP primitives, express them in Terraform, OpenTofu, or CDK, and keep bills and blast radius under control. It clarifies goals and constraints, then applies platform expertise—VPC and IAM, EKS and AKS, Lambda and Functions, RDS and managed SQL, S3 and Blob—and ties choices to resilience, security, and FinOps. Use it when you are past the idea stage and need a concrete, verifiable infrastructure plan rather than ad-hoc console clicking. It spans Validate when scoping environments, Build when integrating cloud services, Ship when hardening launch configs, and Operate when optimizing production spend—Prism shelves it under Build → integrations because the primary artifact is how services connect. Open the bundled implementation playbook when you need step-by-step patterns beyond the SKILL.md summary.534installs215Competitor AlternativesCompetitor Alternatives is an agent skill for solo founders and indie SaaS builders who need comparison pages that rank and still feel trustworthy. It walks you through understanding your product’s real strengths and weaknesses, mapping direct and adjacent competitors, and clarifying whether the page is for SEO capture, sales enablement, or switching users. The methodology stresses honesty—acknowledging where competitors win—because evaluators will verify claims. You get guidance to go deeper than feature matrices, explaining why differences matter across use cases. That makes the output useful for Launch-phase content programs when you are entering crowded categories and need “alternative to” and “vs” pages without generic marketing fluff. Invoke it when you have positioning clarity but need structured, search-aware copy that helps readers decide rather than oversell.534installs216Using Superpowersusing-superpowers is a journey-wide meta skill that trains coding agents to treat the skills catalog as mandatory context, not optional reference material. Solo and indie builders who rely on Claude Code, Cursor, or similar hosts install it to stop agents from answering from general knowledge when a packaged procedure already exists. The skill applies at the start of any conversation and whenever a new task appears, regardless of whether you are ideating, shipping code, or operating production. It explains platform-specific access patterns, demands an explicit announcement when a skill is loaded, and ties checklist-driven skills to todo tracking so nothing is skipped. For Prism readers, it is the behavioral glue that makes directory skills actually run in practice rather than sitting unused in the repo.534installs217Ui SkillsUi Skills is an agent skill that loads opinionated, evolving constraints so coding agents produce interfaces that stay consistent with a maintained UI philosophy rather than one-off aesthetic guesses. Solo builders using Claude Code, Cursor, or similar tools install it when generating dashboards, marketing pages, or product UI where spacing, typography, and component behavior should follow shared rules. The bundled SKILL.md is intentionally lightweight: it directs you to invoke the skill whenever interface work matches that scope and to consult the source repository for the full constraint set. It is not a Figma replacement or automated design tool; it is procedural knowledge that narrows the solution space during implementation. Pair it with frontend framework skills and ship-phase review skills when you need checks after components land in the repo.533installs218Code Refactoring Tech DebtCode Refactoring Tech Debt is an agent skill that acts as a technical debt specialist inside your codebase. Solo builders install it when velocity drops, regressions cluster, or copy-paste patterns make every change expensive. The skill walks through a structured inventory—starting with code debt such as duplication and complexity—then assesses impact and turns the result into an actionable remediation plan focused on measurable improvement rather than vague “cleanup.” It fits moments when you need evidence for what to refactor first, whether you are stabilizing before ship, clearing review blockers, or planning an operate-phase iteration. It is not a generic feature generator; it stays in the debt-analysis and remediation planning lane. Pair it with your agent after you can point the model at the repository (or a defined subtree) and optional focus via arguments.532installs219Executing PlansExecuting-plans is the Superpowers-style execution bridge for solo builders who already have a bite-sized implementation plan and want an agent to stop improvising across the whole spec in one breath. The skill forces a loud announce, critical plan read, concern escalation to the human, then batch execution—by default the first three tasks—with explicit verifications per step. Between batches it surfaces what shipped and waits for feedback instead of silently continuing. That rhythm keeps indie developers in control when plans are ambitious relative to session length. When every task passes, it does not declare victory casually; it requires the finishing-a-development-branch skill so tests, merge options, and branch hygiene get the same rigor as the build itself. Catalog under Build PM because the work is plan-driven delivery, with natural overlap into Ship testing and review during checkpoints.530installs220Environment Setup Guideenvironment-setup-guide is a procedural agent skill that helps developers stand up complete dev environments: inventory requirements, audit what is already installed, then install dependencies, configure env vars, and verify with version checks. Solo builders invoke it when starting a greenfield repo, cloning someone else's stack on a new laptop, or unsticking cryptic "command not found" errors that block ship dates. It is methodology-shaped—repeatable steps rather than a single API—and applies across validate (deciding what you must install), build (daily coding), and operate (reproducing prod-like services locally). The skill does not replace official docs for Node, Python, or Docker; it structures the conversation so agents do not skip prerequisite checks or duplicate installs. Use when you lack a project README setup section or when onboarding docs are stale.527installs221Email SystemsEmail Systems is an agent skill for solo builders who need email to work as infrastructure, not a spammy blast after launch. It walks through splitting transactional and marketing traffic across providers and IPs, building permission-first lists with double opt-in and easy unsubscribes, and implementing deliverability basics including SPF, DKIM, DMARC, and warming new sending reputation. You get principles for automation that converts without poisoning domain reputation, plus concrete good-vs-bad examples for mixed SendGrid misuse versus dedicated transactional routes. Use it when you are wiring signup flows, receipts, lifecycle campaigns, or replatforming off a single shared sender. It pairs well with landing and pricing validation work earlier in the journey and distribution work at launch, but the primary payoff is compounding lifecycle revenue in Grow.524installs222Web Security TestingWeb Security Testing is a workflow skill for solo builders and small teams who need a repeatable OWASP-oriented pass over a web application without inventing phases from scratch. It organizes work into reconnaissance—mapping surface area, stack fingerprinting, endpoints, and subdomains—then moves into injection-focused testing with explicit handoffs to specialized skills for scanning, vulnerability knowledge, SQL injection, and SQLMap-style automation. The SKILL.md is built as a bundle you drive with @-skill prompts, which fits agent coding environments where procedural checklists beat one-off chat advice. Use it when you are validating controls before launch, running an authorized assessment, or structuring bug-bounty recon. It assumes you operate only on systems you own or have written permission to test; the workflow documents actions and skill invokes rather than replacing professional pentest governance or production change control.505installs223Email SequenceEmail Sequence is an agent skill that walks solo builders through designing automated email flows that nurture trust and drive a single conversion goal per touchpoint. It starts with an initial assessment covering sequence type—from welcome and lead nurture to re-engagement and post-purchase—plus who entered the sequence, what they already believe, and how success is measured. The methodology enforces four principles: each message has one primary job and CTA, usefulness comes before asks, fewer relevant emails beat high-frequency blasts, and every link moves the reader forward on a clear path. Founders use it when launching a waitlist drip, onboarding SaaS trials, recovering churned users, or warming leads between validation and purchase without hiring a copy agency. It pairs naturally with landing-page and pricing work in validate and distribution work in launch, but the catalog shelf is grow lifecycle because the durable artifact is a multi-email automation plan tuned to your audience segments.501installs224Angular Ui PatternsAngular UI Patterns is an agent skill that teaches solo builders how to structure Angular components around real async behavior instead of generic spinners everywhere. It centers on five principles: never show stale UI, always surface errors, favor optimistic updates where appropriate, use @defer for progressive disclosure, and degrade gracefully when data is partial. The README gives a concrete control-flow template—error state with retry, skeleton only when loading and empty, empty state, then list—and documents the golden rule that loading indicators appear only when there is no data yet. That pattern maps directly to signal-driven stores and modern @if/@else template syntax, which reduces flicker and confused users in SaaS dashboards and indie admin tools. Invoke it while implementing or refactoring components that fetch lists, handle failures, or stream partial results. It is reference guidance, not a code generator; pair it with your existing API layer and testing habits.499installs225Core ComponentsCore Components is a community design-system skill that tells coding agents how your product UI should be assembled: reach for the shared library, never inline arbitrary pixels or hex colors, and use documented spacing, color, and typography tokens. Solo builders shipping SaaS or mobile clients can attach it whenever the agent is generating screens, forms, or layouts so output matches an existing Tamagui-style or similar token layer. The readme is prescriptive tables and CORRECT versus WRONG examples rather than a multi-step ritual, so it behaves as phase-specific frontend guidance. It does not install components or run Storybook; it shapes agent behavior to align with your system. Use alongside your actual component package names in the repo so the agent imports the right primitives.499installs226Mobile Security Codermobile-security-coder is an agent skill for solo and indie builders who ship mobile apps and need security baked into implementation, not bolted on after launch. It focuses on mobile-specific attack surfaces: validating untrusted input, locking down WebViews and deep links, storing credentials and PII safely on device, and applying authentication flows that resist common client-side mistakes. Invoke it when you are implementing or refactoring mobile code and want procedural best practices, actionable steps, and verification—not when you only need a passive compliance report. The skill contrasts with a dedicated security auditor role: use this one for coding patterns and remediation; use auditors for broad assessment. When you need worked examples, it points you to the bundled implementation playbook for deeper walkthroughs.498installs227Salesforce DevelopmentSalesforce Development is an agent skill that encodes expert patterns for building on the Salesforce platform as a solo or indie builder shipping SaaS on CRM rails or extending an org for a client. It covers Lightning Web Components with wire-based reactivity, Apex triggers and classes, REST and Bulk APIs, Connected Apps, and modern Salesforce DX including scratch orgs and 2GP packaging. Use it when your coding agent needs to generate LWC that follows Lightning Data Service conventions, call Apex safely from the client, or scaffold API integrations instead of generic JavaScript that ignores governor limits and metadata-driven UI. The documented patterns favor @wire for reactive single-record and related-record flows over ad-hoc imperative fetches. It matters because Salesforce’s opinionated stack punishes copy-paste from generic full-stack tutorials—wrong layering costs rework on review and deployment. Pair it with your org’s security model and CI; the skill supplies procedural platform knowledge, not live org credentials.498installs228Data Engineering Data Pipelinedata-engineering-data-pipeline packages architecture judgment and implementation checklists for indie builders and tiny teams who must stand up reliable analytics or product data paths without hiring a platform group. The skill opens with when-to-use boundaries so agents do not drift into unrelated domains, then expects `$ARGUMENTS` so your sources, volume, latency, and targets shape the design. Core capabilities span pattern selection across ETL, ELT, Lambda, Kappa, and Lakehouse models; ingestion for batch and stream; orchestration with Airflow or Prefect; transformation with dbt and Spark; governed storage on Delta Lake or Iceberg; quality frameworks; observability; and cost controls via partitioning and lifecycle policy. Use it while scoping a MVP warehouse, shipping nightly exports, or hardening pipelines before scale. It also informs Operate conversations when monitors and spend guardrails must be explicit.496installs229Web Artifacts BuilderWeb-artifacts-builder is a development tool that enables solo builders to create, test, and manage reusable web components and interactive UI elements. Builders use it when they need to quickly prototype frontends or build component libraries without the overhead of complex build configurations. It matters because it reduces friction in the build cycle and lets developers focus on crafting quality user interfaces.496installs230Context7 Auto ResearchContext7-auto-research is an agent skill that injects fresh framework and library documentation into Claude Code conversations using the Context7 API. Solo builders shipping SaaS or API backends install it when model cutoff knowledge is too stale for the exact React, Next.js, or Prisma version in their repo. The skill is meant to auto-trigger when you ask how a library works today, reducing wrong signatures and deprecated patterns during active coding. It spans multiple journey moments: primary placement is Build while you integrate and read docs, but the same lookups help during Ship when debugging version-specific behavior. Setup is lightweight via the documented npx skills add command, with optional API keys for rate limits. It is research-oriented integration—not a substitute for running tests or reading your own lockfile—and works best alongside other search skills when Context7 does not index a niche package.495installs231Subagent Driven DevelopmentSubagent-driven development is an agent workflow skill for solo builders who already have a written plan and want execution split across focused subagents instead of one long chat thread. You dispatch a general-purpose implementer with the full task description, scene-setting context, and encouragement to clarify requirements before coding, then—only after spec compliance is satisfied—you dispatch a code-quality reviewer using the requesting-code-review template. The pattern fits Claude Code–style Task tools and Superpowers-style stacks where implementation and review are separate roles with clear handoffs. It reduces scope drift by forcing the implementer to confront ambiguities upfront and prevents premature style nitpicks when requirements are not yet met. Use it when plan tasks are nontrivial, when you want test-backed implementations, and when you need an auditable review narrative tied to specific SHAs rather than a vague “looks good.”494installs232Cc Skill Continuous LearningContinuous Learning is a meta skill for Claude Code owners who want yesterday’s firefight to become tomorrow’s one-line invoke. A Stop hook runs evaluate-session.sh after sessions that meet a minimum length threshold, scans for durable patterns such as error resolution, user corrections, workarounds, debugging techniques, and project-specific conventions, and materializes vetted snippets into personal learned skills under ~/.claude/skills/learned/. Configuration in config.json controls extraction sensitivity, auto-approval, and ignore lists so one-off typos and external API blips do not pollute your library. Because it hooks session end—not every prompt—it avoids adding latency to normal coding. Solo builders benefit across Idea research dead-ends, Validate spikes, Build feature work, Ship regressions, and Operate incidents alike: any long session can feed the evaluator. You still review extracted skills when auto_approve is false, keeping human judgment in the loop.493installs233Agent Orchestration Improve AgentAgent Orchestration Improve Agent is a workflow skill for solo and indie builders who already run an AI coding agent and need it to fail less often, use tools correctly, and stay stable after edits. The skill frames optimization as engineering: collect representative runs and user feedback, establish baseline metrics, cluster failure modes (bad prompts, wrong tool calls, ambiguous instructions), then apply targeted prompt and workflow changes with measurable goals. It expects you to validate every change with tests or evaluation suites and roll out in controlled stages so you can revert if regressions appear. That makes it a practical companion during active development when you are iterating on SKILL.md packs, sub-agents, or MCP-backed flows, and again in production-minded phases when you are watching error rates and support burden. It deliberately excludes greenfield agent architecture and empty feedback loops, keeping focus on measurable iteration rather than brainstorming a new persona from scratch.491installs234Onboarding CroOnboarding-cro is a community agent skill that treats user onboarding as conversion-rate optimization for activation. It prompts you to clarify product type, B2B versus B2C positioning, the aha moment, current activation rate, and what happens immediately after signup before recommending changes. Core principles stress shrinking time-to-value, focusing the first session on a single successful outcome, and prioritizing doing the core job over watching tutorials. Solo builders shipping SaaS, marketplaces, or consumer apps can use it to critique empty states, checklist overload, and onboarding that teaches features instead of delivering value. It pairs naturally with landing and pricing work earlier in the journey but lives on the Grow shelf because the measurable win is retained, activated users—not a one-time UI build ticket.489installs235Codex ReviewCodex-review packages a Ship-phase review ritual for solo builders who want agent-assisted scrutiny before commits, not drive-by chat feedback. It targets pre-commit review, automatic CHANGELOG maintenance, and passes over large refactors where missed regressions are costly. Installation is documented via npx skills add against the BenedictKing/codex-review package, with Codex CLI called out as a dependency for the integrated flow. Best practices emphasize keeping CHANGELOG.md in the repo root and using conventional commit messages so generated changelog entries stay parseable. The skill positions itself alongside research-oriented skills but stays in the review lane—it does not replace CI, security scanners, or environment-specific test suites. Treat output as structured review input you still validate locally before shipping.488installs236Frontend Slidesfrontend-slides is an agent skill that equips solo builders to produce presentation experiences with intentional motion design. Rather than generic slide transitions, it documents how animation choices signal drama, futurism, friendliness, corporate polish, calm minimalism, or editorial magazine rhythm, with tables linking feelings to durations, colors, and layout habits. Builders use it when generating pitch decks, product walkthroughs, launch pages, or conference demos where HTML/CSS is the delivery format. The reference emphasizes copy-paste CSS blocks—reveal classes, scale-ins, and easing tokens—so an agent can align visuals with brand tone without guessing. It pairs well with storytelling and validation work upstream and distribution assets downstream, but the implementation work lives in frontend presentation code.487installs237Schema MarkupSchema Markup is an agent skill for solo builders who need structured data that search engines can trust, not copy-pasted JSON-LD from blog posts. It positions the assistant as a structured-data expert focused on Google rich result eligibility, factual alignment with on-page content, and sustainable maintenance. Before any code changes, the skill requires a Schema Eligibility & Impact Index on a 0–100 scale across alignment, eligibility, completeness, technical correctness, and maintenance—framed as diagnostic, not a promise of snippets. The workflow discourages schema that exaggerates offers, reviews, or entity types and steers toward valid, minimal JSON-LD that matches what users actually see. Launch-phase founders use it when shipping marketing sites, SaaS landing pages, docs, or product catalogs where FAQ, Article, Product, or Organization types might apply. It complements content strategy and technical SEO audits but does not replace Core Web Vitals work, backlink outreach, or AEO content design on its own.487installs238Verification Before CompletionVerification Before Completion is a journey-wide agent discipline from the antigravity-awesome-skills collection. Solo builders use it whenever an AI assistant might declare victory without running commands: passing tests, clean lint, green builds, or generic 'looks good' statements. The skill encodes an iron law and a repeatable gate—identify the verifying command, execute it fresh and completely, read exit codes and failure counts, and only then align spoken status with evidence. That procedural knowledge reduces false confidence during Build integrations, Ship testing and review, Launch hotfixes, and Operate incident checks. It pairs naturally with code-review and testing skills but does not replace them; it governs how claims are made after those tools run. Install it when you have seen agents extrapolate from stale logs or partial checks. Keep it active across Claude Code, Cursor, and Codex sessions where autonomy touches the repo.487installs239Trigger DevTrigger.dev Integration is an agent skill for solo and indie builders who need production-grade background processing without maintaining Redis workers or bespoke retry logic. It encodes Trigger.dev’s mental model: tasks as building blocks, durable runs, explicit concurrency limits, and integration-first API calls so failures retry at the right boundary. The readme scopes the skill to Trigger.dev itself and points adjacent patterns (BullMQ, Inngest, Temporal) when you need different infrastructure shapes. Use it when you are adding AI pipelines, batch jobs, scheduled syncs, or webhook-driven workflows in a TypeScript codebase and want the agent to follow SDK, CLI, and deployment conventions consistently. It matters because async work is where small teams lose nights to silent failures; this skill pushes observable logs, queue discipline, and dev/prod parity from day one.483installs240Programmatic SeoProgrammatic SEO is an agent skill for solo and indie builders who are tempted to generate large numbers of search-driven pages from templates and databases. It treats programmatic SEO as a structural decision, not a shortcut: before any page architecture is proposed, you run the Programmatic SEO Feasibility Index, a 0–100 diagnostic that weights search-pattern validity, per-page unique value, data availability, and related risk factors. The skill helps you decide whether programmatic SEO is appropriate at all, scores feasibility and downside, and outlines a system that preserves usefulness for users and crawlers. It is strongest when you have repeatable entities (locations, integrations, comparisons) and real data to differentiate each URL. It deliberately avoids implementing pages by default so you can validate scope during validation, design during build planning, and execute during launch and grow without publishing a thin-content footprint.481installs241Using Git WorktreesUsing Git Worktrees teaches coding agents to create isolated workspaces that share one repository so you can run multiple branches at once without constant git checkout churn. The workflow is explicit: pick a worktree root in priority order, honor CLAUDE.md if it names a directory, ask the user only when needed, and verify ignore rules before writing files beside your main tree. Solo builders juggling a hotfix and a feature, or running a long agent job on a side branch, use this skill to keep the primary workspace clean. It is tagged multi-phase because the same isolation helps during Build when implementing, Ship when review or release branches run in parallel, and Operate when you patch production from a dedicated tree. Frontmatter marks risk as critical—mistakes can expose unignored worktree paths or confuse agents about which cwd is authoritative. Announce the skill at start and treat verification steps as hard requirements, not suggestions.481installs242Cc Skill Coding Standardscc-skill-coding-standards packages universal engineering habits—readability, simplicity, duplication control, and deferring speculative features—for agents working in TypeScript, JavaScript, React, and Node. Indie builders who bounce between a Next.js UI, a small Express API, and automation scripts use it so every session names things clearly, avoids clever one-offs, and does not sprawl features ahead of validation. Because the description positions it as applicable across projects, treat it as journey-wide process knowledge: invoke before substantial implementation in Build, when refactoring during Operate, or when reviewing diffs in Ship. The readme supplies concrete naming templates and marked good/bad snippets, which agents can apply without a separate linter. It complements framework-specific skills rather than replacing ESLint or Prettier; it steers how the agent reasons about structure and change size before those tools run.478installs243Observability EngineerAn observability engineer skill for designing and implementing comprehensive monitoring, logging, and tracing systems at production scale. Solo builders use this when establishing reliability targets (SLIs/SLOs), investigating performance issues, or building dashboards aligned to business metrics. It matters because production systems require real-time visibility into performance, errors, and user impact to maintain reliability and enable rapid incident response.478installs244Avalonia Viewmodels ZafiroAvalonia-viewmodels-zafiro teaches solo and indie .NET builders how to keep Avalonia desktop apps maintainable by centralizing ViewModel-to-View wiring through Zafiro’s DataTypeViewLocator and a explicit composition root. You register the locator and framework data templates in Application.DataTemplates, then bootstrap the shell from a static CompositionRoot that composes Microsoft.Extensions.DependencyInjection—AddViewModels, AddUIServices with the top-level Control, and GetRequiredService for IShellViewModel. The skill emphasizes correct mapping boundaries so new screens stay convention-driven instead of hard-coded view switches. It fits cross-platform Avalonia products (Windows, macOS, Linux) where you want reactive UI patterns without reinventing navigation glue each sprint.475installs245Launch StrategyLaunch Strategy is an agent skill that acts as a SaaS launch and feature-announcement coach for solo founders who must market without a growth team. It encodes a core philosophy: great companies relaunch continuously—each improvement is a new moment to capture attention and learn from real users. The ORB framework structures marketing across owned channels you control (email, blog, podcast, community, product), rented platforms with algorithms, and borrowed reach through partners and press, with everything ultimately strengthening owned relationships. Use it when planning a first ship, a major feature drop, or a smaller update you want to treat as a marketing event. The skill pushes momentum that compounds rather than a single vanity spike. It fits indie builders wearing product, content, and distribution hats who need a checklist-level channel strategy tied to audience reality. It does not replace analytics instrumentation or ASO/SEO technical work—it orients what to say, where, and in what sequence so later Grow and Launch skills have a coherent narrative.474installs246Cc Skill Project Guidelines ExampleCC Skill Project Guidelines Example is a meta template showing how to write a project-specific agent skill so Claude Code and similar tools stop improvising on your stack. It mirrors a real production shape: Next.js 15 on the frontend, FastAPI and Pydantic on the backend, Supabase for Postgres, Claude with tool calling, and Cloud Run deployment, with Playwright, pytest, and React Testing Library called out for quality gates. Solo builders install it as a copy-paste blueprint—architecture diagram, service boundaries, patterns, testing requirements, and deploy flow—then replace Zenith placeholders with their own repo facts. Use it whenever you onboard an agent to a long-lived codebase and need consistent edits across validate-through-operate work without re-explaining conventions each session. It does not replace your actual SKILL.md content; it teaches the structure Prism and skills.sh users expect for trustworthy project skills.473installs247Dispatching Parallel AgentsDispatching Parallel Agents is a workflow skill for solo and indie builders who use Claude Code, Cursor, or Codex when several failures appear at once but do not share a single root cause. Instead of one long chat that context-switches across unrelated stack traces, you assign each independent domain—separate test files, services, or bug classes—to its own agent and let them run concurrently. The embedded decision diagram forces you to check independence and shared state before choosing parallel dispatch, which prevents race conditions and duplicate fixes. It matters most during ship-phase test red builds and operate-phase incident piles where breadth beats depth in sequence. The skill is prompt-only procedural knowledge: no MCP, no shell requirements beyond what your agents already use. Pair it with systematic debugging skills for each branch after dispatch, and reserve single-agent investigation when failures are causally linked.473installs248Memory SystemsMemory Systems is a design-oriented agent skill for solo builders shipping Claude Code, Cursor, or custom agents that must not “forget” users, projects, or decisions every session. It walks through why naive context-only setups fail at scale and how layered architectures balance immediate prompts with durable stores—vectors for similarity recall, graphs for relationships and constraints, and temporal graphs when history and validity intervals matter. You activate it when sketching persistence for support bots, coding copilots with repo memory, or internal tools that learn from past tickets. The skill is methodology and architecture guidance, not a single-database installer: you still pick vendors, schemas, and privacy boundaries. Expect intermediate-to-advanced context-engineering vocabulary and tradeoff framing rather than copy-paste Terraform.473installs249Moodle External Api DevelopmentMoodle external API development walks solo builders and small edtech teams through creating custom web services in Moodle LMS plugins using the official external_api framework. You add a class under local/yourplugin/classes/external/, define input and return schemas with external_function_parameters and external_single_structure, then implement business logic in execute() with proper capability and context checks. The skill targets REST and AJAX consumers—mobile apps, external reporting tools, and automation that must call Moodle securely. It assumes you already run a Moodle instance and are comfortable with PHP plugin layout. Outputs are production-shaped PHP endpoints registered in Moodle’s web services UI, not generic OpenAPI stubs. Skip it if your product is not Moodle-based; use it when you are extending LMS behavior rather than replacing Moodle outright.473installs250Theme FactoryTheme-factory is listed in the antigravity-awesome-skills bundle as a design-oriented agent capability for producing cohesive visual themes—typically color palettes, typography pairing, and surface treatments you can apply across a SaaS dashboard, landing page, or browser extension. Prism’s ingest captured primarily Apache 2.0 license text rather than a full SKILL.md procedure, so treat this page as a discovery anchor and confirm the upstream skill README in your checkout before relying on step order. Solo builders still install skills like this when they want the agent to propose structured theme variants (light/dark, brand accents, accessibility-conscious contrasts) instead of improvising styles per screen. Reach for it during Build while scaffolding UI, during Validate when a prototype needs a credible visual identity, or during Launch when marketing pages must match the in-app look. After themes are chosen, you usually codify tokens in CSS variables, Tailwind config, or a component library theme provider and run a quick contrast check before shipping.473installs251Form CroForm-cro is an agent skill for solo builders who run landing pages, demo funnels, or checkout paths with complex data needs and suspect invisible friction is killing completions. It treats form optimization as a measured discipline: you must run the Form Health & Friction Index first, a 0–100 structural diagnostic across six weighted categories, so you do not rip out fields on gut feel or optimize in isolation from why the form exists. The skill guides value–effort balancing, cognitive load reduction, error recovery, trust cues, and mobile usability while refusing to equate shorter forms with better leads. Install it when you are validating a prototype offer, polishing a launch campaign form, or tuning grow-stage lifecycle captures such as surveys and quote requests. It pairs naturally with analytics review after changes ship. Intermediate operators get phased recommendations grounded in friction science rather than generic UX platitudes.472installs252Customer Supportcustomer-support is an agent skill that casts the assistant as a customer support specialist for indie SaaS and product teams: clarify goals and constraints, apply support best practices, and return actionable, verifiable steps for conversational AI, ticketing automation, sentiment-aware replies, and omnichannel journeys. It is meant for Grow-phase operators who are wiring their first helpdesk bot, refining macros, or designing escalation paths without a dedicated support org. The readme keeps scope tight—use it for support tasks and checklists, skip it for unrelated domains—and defers extended examples to an implementation playbook resource. Expect guidance and structure rather than a single integration to one vendor API; you bring your stack (Zendesk, Intercom, custom inbox) and validate outcomes against your SLA and tone guidelines.470installs253Avalonia Zafiro DevelopmentAvalonia Zafiro development is a rules-and-checker agent skill for solo builders shipping cross-platform desktop apps on Avalonia with Zafiro and ReactiveUI. It tells your coding agent to treat MVVM boundaries as non-negotiable: ViewModels stay free of Avalonia references, UI behavior flows through bindings and explicit DataTemplates, and collection-heavy screens use readable DynamicData operator chains with DisposeWith for lifecycle control. Zafiro abstractions and validation helpers should be preferred over reinventing plumbing. The skill also calls out explicit anti-patterns—creating throwaway SourceCache instances, stuffing business logic into Subscribe, and mixing Rx where DynamicData already fits—so reviews stay consistent across sessions. Use it whenever you or an agent touch Avalonia views, reactive lists, or Zafiro integration in an existing solution.468installs254Paywall Upgrade CroPaywall Upgrade CRO is an agent skill for solo builders shipping freemium SaaS or mobile apps who need paywalls that convert without nuking trust. It treats upgrade screens as conversion surfaces, not apology modals: you clarify whether the goal is freemium-to-paid, trial conversion, tier uplift, feature upsell, or usage-cap expansion, then align the prompt with what the user was trying to do when they hit the gate. Core principles are value before ask, tangible previews of paid capabilities, and a low-friction path to checkout when timing is right—typically after the user has experienced enough benefit to justify commitment. The skill asks for your product model (what stays free forever, what sits behind the paywall, current triggers and conversion rate) so recommendations stay specific rather than generic SaaS folklore. Use it while shaping Validate pricing hypotheses, polishing Ship-ready paywall UX, or iterating Grow lifecycle experiments; skip it for backend billing integration alone or brand-new ideas with no prototype yet.468installs255Obsidian Clipper Template CreatorObsidian Clipper Template Creator is an agent skill for solo builders who want web pages to land in Obsidian as tidy, repeatable notes instead of paste dumps. It guides you through authoring Obsidian Web Clipper template JSON: note content formats with mustache-style variables, frontmatter-style properties for source and author, folder paths such as Clippings/, and specialized layouts like Recipe that pull schema.org Recipe fields into markdown sections. Use it when you are standing up a second brain, competitive research library, or content swipe file and need one-click capture with consistent tags. The skill fits builders using Claude Code or Cursor alongside Obsidian; it does not run the clipper itself but produces the template artifacts you import into the extension. Pair with your vault conventions first so categories and wikilinks match how you already organize ideas, ship notes, and iterate on what you clipped during build and growth.467installs256Ai Agent Developmentai-agent-development is a granular workflow bundle that walks solo builders through designing and shipping AI agents—from purpose and capabilities through framework choice, tools, memory, and behavioral tests. It targets autonomous agents, multi-agent crews, and orchestration patterns using CrewAI, LangGraph, and custom implementations. Invoke it when you are past a vague chatbot idea and need a repeatable sequence: architect the agent, implement single-agent logic, then extend to coordination and production concerns named in later workflow phases. The skill is categorized as safe procedural guidance and pairs with companion skills like ai-agents-architect and autonomous-agent-patterns via documented copy-paste prompts. Multi-phase journey placement reflects that architecture decisions echo Validate scoping while hardening overlaps Ship testing. It does not replace infrastructure provisioning or security review, but it gives indie developers a structured agent build runway inside Claude Code, Cursor, or Codex.466installs257Security Scanning Security HardeningSecurity-scanning-security-hardening is a coordinated agent workflow for solo and small teams who need more than a one-off vulnerability scan. It walks through establishing a security baseline, remediating high-risk findings, then implementing and validating layered controls so releases are defensible under real threats. The skill is built for builders shipping SaaS, APIs, or CLI-backed services who want DevSecOps-style depth without hiring a full AppSec bench. It assumes you have authorization to test and change the environment; it is not a lightweight linter pass. Phases chain findings forward so each round of controls addresses what earlier discovery surfaced. Use it when you are preparing a meaningful launch or tightening production posture after growth exposes new attack surface.466installs258Documentation Generation Doc GenerateDocumentation-generation-doc-generate is an implementation playbook skill that helps solo builders turn an under-documented codebase into shippable knowledge assets without hiring a tech writer. It walks the agent through five parallel tracks: inferring API surfaces into OpenAPI or Swagger plus interactive Redoc or Swagger UI, explaining system shape with architecture diagrams and dependency narratives, enriching code with docstrings and README sections including configuration and troubleshooting, and drafting user-facing tutorials for common workflows. A fifth track pushes documentation into CI so generated sites stay current through linting, coverage-style checks, and automated publishing. The skill fits indie SaaS and API products where the same person owns backend routes and public docs. Use it during active build passes, before security or launch reviews when contracts must be explicit, and when onboarding collaborators who need accurate setup steps rather than stale wikis.465installs259Upstash QstashUpstash QStash is a serverless message queue and scheduling platform that delivers messages to HTTP endpoints reliably without managing any infrastructure. Solo builders use it to implement async workflows, delayed messages, and scheduled jobs across serverless applications. It matters because it reduces the complexity of building reliable background job systems—retries, deduplication, and cron scheduling are built-in, letting developers focus on business logic instead of queue management.465installs260Machine Learning Ops Ml PipelineMachine-learning-ops-ml-pipeline is an agent skill that walks you through designing and implementing a complete machine learning pipeline using a multi-agent MLOps orchestration model. It is aimed at solo and indie builders who want experiment tracking, feature management, and model serving wired together instead of a one-off notebook deploy. Use it when you are standing up or refactoring a pipeline for a concrete use case ($ARGUMENTS) and need modern tooling choices, phase coordination, and verification steps aligned with production practice. The skill emphasizes reproducibility, monitoring, and reliability from the first design pass rather than bolting ops on later. Open the bundled implementation playbook when you need deeper examples; otherwise follow the clarify-goals, apply-best-practices, and validate-outcomes loop in the instructions.463installs261Page Cropage-cro is an agent skill for page-level conversion rate optimization aimed at solo founders and marketers who own a single high-stakes URL—a landing page, pricing page, or campaign destination. It acts as an expert reviewer that diagnoses why a page may fail to convert, runs a mandatory Page Conversion Readiness & Impact Index, and outputs prioritized, evidence-based recommendations rather than promising lift. The index weights value proposition clarity, conversion goal focus, traffic–message match, trust signals, UX friction, and objection handling to steer work away from cosmetic tweaks. Use it when you have traffic or a launch plan but unclear conversion leaks, or before expensive tests. It spans validation of landing hypotheses and later launch/growth tuning on the same asset.462installs262Api Security Testingapi-security-testing is a granular workflow bundle that guides your agent through disciplined API security assessment for REST and GraphQL surfaces. It starts with discovery—enumerating endpoints, methods, parameters, and documentation—then moves into authentication tests such as API keys, JWT validation, OAuth2 flows, expiration, and refresh handling, followed by authorization testing including IDOR-style risks called out via companion skill references. Solo builders shipping SaaS APIs or indie microservices use it before public launch, prior to bug bounty submissions, or when onboarding a new mobile client that talks to the same backend. The skill is procedural rather than a single scanner invocation: it names phases, actions, and @-style skill handoffs so you can layer fuzzing and best-practice checklists without ad-hoc prompt sprawl. Risk metadata in the pack marks it safe in the sense of guidance, but executing tests against systems you do not own or without permission is out of scope ethically and legally.461installs263Skill Seekersskill-seekers packages the Skill Seekers workflow for agents that need to mint new skills quickly. Solo builders point it at living documentation, open-source repos, or PDFs and get structured skill artifacts suitable for Claude-style agents without manually transcribing every API page. It sits in Build agent-tooling because the output is reusable procedural knowledge for your coding agent, not a shipped customer feature. The readme stresses clear scope: use when the job is conversion, then validate permissions, licensing, and factual accuracy in your environment. Pair it after you have identified which external corpus should become a skill and before you wire that skill into daily invoke rules or marketplace listings.461installs264Ui Visual Validatorui-visual-validator is an agent skill for solo builders and designers who ship interfaces through AI-assisted coding and need a skeptical second pass on what users actually see. It encodes a visual validation expert mindset: treat every UI change as incomplete until screenshots or live UI evidence support the claim. The workflow emphasizes design system consistency, accessibility checks, and critical hunt for flaws, inconsistencies, or partial implementations—explicitly ignoring code-only arguments. It fits the Ship phase when you are closing UI tasks, preparing launches, or regression-checking after refactors. Intermediates benefit most when they already have a target design or component library but lack disciplined visual QA habits. Open the implementation playbook when you need step-by-step verification patterns beyond the core principles.460installs265Requesting Code ReviewRequesting Code Review is an agent skill that turns your coding agent into a production-readiness reviewer for a bounded changeset. You supply what was implemented, the plan or requirements reference, and base/head SHAs so the agent inspects the real diff—not a verbal summary. The checklist pushes separation of concerns, error handling, type safety, DRY usage, edge cases, scalability, security, and whether tests exercise logic rather than mocks only. Requirements coverage checks for scope creep, breaking changes documentation, migrations, and backward compatibility. Solo builders use it right before merge or ship when they want severity-tagged feedback without waiting on a human reviewer, or when pairing agent implementation with a formal gate. It complements planning skills: approved specs still need diff-level verification. Complexity is intermediate because you must maintain accurate SHAs and a readable plan artifact. Deliverables are a structured review memo with strengths and prioritized issues, not automatic fixes.458installs266Signup Flow CroSignup-flow-cro is a conversion-focused agent skill that treats registration as a product surface, not a bureaucratic form. It opens by forcing clarity on flow type—free trial, freemium, paid account, waitlist, B2B versus B2C—and on measurable reality: how many steps you use, which fields are mandatory, where users abandon, and what must legally be collected up front. From there it applies CRO principles solo builders often skip when shipping fast: challenge every field, defer nonessential data, show product value before asking for passwords or billing details, and align the post-signup path with activation rather than an empty dashboard. Use it when completion rate is soft, when you are launching a new pricing tier, or when compliance pushed you into a twelve-field signup you suspect is killing growth. The skill is advisory and structured rather than a wireframe generator; you still implement UI changes in your stack and validate with analytics after deploy.458installs267Code Review ExcellenceCode Review Excellence is an agent skill that turns pull-request review into constructive, teachable feedback rather than gatekeeping. Solo and indie builders shipping through GitHub or similar workflows install it when they need a repeatable lens on diffs: context first, then systematic checks for bugs, security holes, performance traps, and long-term maintainability. The skill asks clarifying questions when intent is unclear and explicitly avoids replacing implementers—it is for reviewing existing changes, not greenfield design debates or writing fixes. Output is organized for action: a high-level summary, findings grouped by severity (blocking, important, minor), concrete suggestions, open questions, and test or coverage notes. When you need heavier checklists, it points to an implementation playbook resource. Use it on every meaningful PR when you wear both author and reviewer hats, or when you want your agent to emulate a senior reviewer who explains why something matters, not just that it is wrong.457installs268Brand Guidelinesbrand-guidelines is a community Sentry voice skill for solo builders and tiny teams who ship product UI and docs without a dedicated content designer. Use it whenever you write or rewrite user-facing strings—labels, forms, errors, empty states, onboarding, 404 pages, documentation, or marketing—and need a consistent choice between Plain Speech and Sentry Voice. The skill ships a decision table so default product chrome stays clear and functional while personality surfaces get intentional tone. It is not a generic copywriting prompt; it encodes Sentry-specific brand rules including concision, active voice, and jargon avoidance. Place it early in Build when naming features and late in Launch when polishing announcement copy. Confidence is high for Sentry-aligned products; adapt metaphors if you fork the rules for another brand.456installs269Startup Business Analyst Market Opportunitystartup-business-analyst-market-opportunity guides an agent through a structured market opportunity analysis for early-stage products. It walks solo founders from defining customer segments and collecting data through bottom-up TAM math, top-down validation, SAM filters, and a realistic obtainable market estimate over three to five years. The skill is intentionally interactive—goals and constraints are clarified up front—and points to an implementation playbook when the user needs worked examples. On Prism’s journey it anchors Idea research when exploring niches and Validate scope when translating opportunity into build boundaries, without replacing live primary research or legal investment advice.456installs270Design OrchestrationDesign Orchestration is a routing meta-skill for solo builders and small teams who treat agent-assisted coding as a product decision, not a typing shortcut. When someone proposes a feature, system change, or architecture shift where correctness beats speed, this skill decides what runs next: mandatory brainstorming with named artifacts, a risk tier, optional multi-agent design review, and only then permission to invoke implementation or planning skills. It explicitly does not create designs; it enforces order and escalation so ideas become reviewed designs before code. Use at the boundary between validating what to build and starting build work. Intermediate complexity—you must already have brainstorming and multi-agent brainstorming skills in the same workflow library.455installs271Code Documentation Doc GenerateAutomated Documentation Generation is an agent skill playbook for solo builders who ship fast but owe users, contributors, and future-self clear references. It walks an agent through extracting API contracts into OpenAPI specifications, documenting service topology with architecture diagrams, enriching code with docstrings and README setup guides, and publishing user-facing tutorials for common workflows. A dedicated automation section pushes teams toward pipelines that regenerate docs on merge, lint prose and structure, and track documentation coverage so drift is visible. The skill fits Claude Code and Cursor workflows where the agent already has repo access and can iterate files in place. Treat it as a generator-oriented checklist rather than a single-format template: outputs should match your stack’s doc site, whether static MDX, Redoc, or internal wikis.453installs272Outlook AutomationOutlook Automation via Rube MCP is a community agent skill that teaches coding agents to operate Microsoft Outlook through Composio’s Outlook toolkit exposed on Rube MCP. It targets solo builders who want calendar, contact, folder, attachment, and mail automation inside Claude Code, Cursor, or similar clients without writing and maintaining Microsoft Graph integrations by hand. The documented path is deliberate: confirm RUBE_SEARCH_TOOLS responds, connect the outlook toolkit with RUBE_MANAGE_CONNECTIONS and complete OAuth, then follow named tool sequences—starting with KQL-based OUTLOOK_SEARCH_MESSAGES and optional detail and attachment steps. Because schemas change, the skill insists on searching tools first rather than hard-coding assumptions. Use it when building personal or small-team agent assistants that triage inbox noise, fetch messages for support workflows, or prepare outbound comms while you stay in the editor.453installs273Api Fuzzing Bug BountyAPI Fuzzing Bug Bounty is a procedural skill for solo builders and small teams who ship APIs and need structured offensive testing only under explicit authorization—bug bounty programs, client pentests, or lab targets. It maps REST, SOAP, and GraphQL differences, then walks core workflows for discovery fuzzing, authentication weaknesses, IDOR chaining, and injection-class findings using Burp Suite-class proxies, API wordlists, and light Python scripting. Outputs emphasize reproducible proofs and documentation suitable for remediation tickets, not drive-by scanning of systems you do not own. Pair it with your Ship security checklist before Launch when external researchers or customers will hammer the same routes.452installs274BlockrunBlockRun is an agent integration skill that gives Claude Code and Google Antigravity paid access to capabilities the base agent lacks, such as image generation, live X search, and cheaper or second-opinion LLM routes. It documents x402 micropayment routing to OpenAI, xAI, Google, and other providers through a wallet you fund, with transparent per-call pricing in the skill table. Solo builders use it while wiring agent tooling so prototypes and automations can call external models without juggling multiple API dashboards. Optional budget tracking in blockrun_llm lets you honor user spend limits and report total USD at the end of a session. It fits the build phase when you need autonomous capability purchases during integration work, not when you only need local code generation.452installs275Angular Best PracticesAngular Best Practices is a performance-oriented agent skill that packages sickn33’s prioritized rules for solo builders shipping Angular apps with modern signals, lazy loading, and SSR. Reference it when writing new components, tuning data fetching, shrinking bundles, or reviewing PRs for change-detection and rendering waste. The guide orders seven impact tiers—from critical change detection and async waterfalls through bundle and defer strategies to medium template optimizations—so agents attack bottlenecks in the right sequence instead of generic style nits. It suits indie SaaS dashboards and internal tools where one developer owns frontend velocity and Core Web Vitals. Use during implementation in Build and again in Ship when reviewing or hardening performance before release; skip when the codebase is not Angular or when you only need visual design tokens without runtime behavior changes.451installs276Context Optimizationcontext-optimization teaches procedural patterns for making limited LLM context windows behave larger in real agent systems. Solo builders shipping Claude Code, Cursor, or Codex workflows hit walls when transcripts, tool outputs, and specs accumulate; this skill frames optimization as signal preservation through compaction near limits, masking verbose observations with references, reusing KV-cache where possible, and partitioning work across isolated contexts. It is intermediate-to-advanced material aimed at production-minded indies optimizing billable tokens and response time, not beginners writing their first prompt. Canonical placement is Build agent-tooling, with strong carryover to Operate when agents run continuously in production. Activate when complexity outgrows the window, when you are implementing multi-step agents, or when unit economics matter at scale. Outcomes are architectural choices and compression habits—not a single generated file—so pair with your existing agent framework conventions.451installs277Receiving Code Reviewreceiving-code-review is a community agent skill that teaches how to process human review comments like an engineer, not a cheerleader. Solo builders using Claude Code, Cursor, or Codex often let agents auto-agree and batch risky edits; this skill installs a fixed loop—read fully, restate requirements, verify against the repo, evaluate fit, respond with technical reasoning, then implement and test one change at a time. It explicitly bans hollow praise and premature “implementing now” jumps when items are ambiguous, which protects small teams from mis-scoped fixes across related review bullets. Journey-wide placement fits because the same rules apply during Build PRs, Ship review gates, Grow refactors, and Operate hotfix threads. Pair it with submission-side review skills for outbound quality, but use this one whenever you are on the receiving end of feedback.451installs278Rust Prorust-pro is an agent skill that positions the model as a Rust expert for modern 1.75+ development, including advanced async programming, trait and lifetime design, and production-oriented systems work. Solo builders invoke it when implementing Rust services, libraries, or tooling and need help with ownership, async architecture, crate selection, testing, linting, and profiling. The instructions require clarifying performance, safety, and runtime constraints before choosing an async runtime and ecosystem, then implementing with tests and optimizing hotspots. It explicitly avoids quick dynamic scripts, bare syntax tutorials, or projects that cannot adopt Rust. For Prism’s audience shipping agents, CLIs, and APIs, it sits in Build backend as procedural expertise rather than a single integration hook.451installs279Golang ProGolang-pro casts the agent as a senior Go engineer focused on Go 1.21 and later: generics, workspaces, context-driven cancellation, embedding assets, and compiler-aware habits. Solo builders install it when shipping backends, CLIs, or small microservices and need opinionated help on goroutine patterns, API shape, observability hooks, and performance work without leaving the agent session. The skill starts by confirming Go version and tooling constraints, then selects concurrency and architecture approaches, implements with tests and profiling in mind, and closes with latency, memory, and reliability tuning. It deliberately excludes pure language tutoring or stacks where Go cannot be chosen, so prompts stay actionable for repos you can actually build and deploy. For Prism’s Build journey, it complements generic planning skills by turning approved specs into idiomatic, maintainable Go that survives real traffic and iterative refactors.450installs280Accessibility Compliance Accessibility AuditAccessibility Compliance Accessibility Audit is an agent skill playbook for solo builders who need repeatable WCAG automation instead of one-off manual passes. It centers on an AccessibilityAuditor class that launches headless Chromium via Puppeteer, loads a target URL, and runs @axe-core/puppeteer analysis with standard WCAG tag sets. Results normalize into violations with per-node failure summaries so you or your coding agent can file tickets or patch markup systematically. Default posture targets WCAG AA at a 1920×1080 viewport, which matches common production layouts while staying strict enough for compliance conversations. The weighted scoring model ties business priority to axe impact levels so critical blockers surface first. Use it while hardening frontend features during build, again in ship-phase QA, and when revisiting pages after redesigns. It is procedural knowledge packaged as copy-paste JavaScript patterns rather than a hosted SaaS scanner, which keeps you in control of CI secrets and scan scope.449installs281Wordpress Penetration TestingWordPress Penetration Testing is an agent skill for solo builders and small teams who need a structured, authorized security pass on WordPress—especially as WordPress 7.0 expands real-time collaboration, AI connector endpoints, and machine-callable Abilities APIs. It documents how to reason about RTC session hijacking, sync meta storage, prompt injection against AI routes, manifest exposure, and permission boundaries—not a substitute for written client permission. The skill aligns with Ship-phase security: enumerate versions and plugins, map JSON REST attack surface, and prioritize findings before production launch. It explicitly flags offensive risk and community authorship so you pair agent output with human judgment and your own rules of engagement. Do not use it against sites you do not own or lack contract coverage for; treat outputs as input to remediation tickets and retests, not live exploitation playbooks on production without isolation.446installs282Api Testing Observability Api MockAPI Mocking Implementation Playbook is an agent skill that walks solo builders through building a comprehensive mock API server on FastAPI rather than hand-waving fixtures in tests. It centers on a MockAPIServer class with explicit setup for middleware, mock route definitions, dynamic endpoints, and scenario initialization so dependents—mobile apps, SaaS dashboards, or coding agents—can exercise contracts without hitting flaky third parties. The included patterns cover state management across requests, scenario managers for happy-path versus error cases, and response headers that make mocks observable in logs and traces. For indie teams shipping APIs or consuming external APIs, this skill reduces integration risk during Ship by making failure modes testable on demand. It pairs naturally with contract tests and observability work; it does not replace security review or load testing of the real service.442installs283Network EngineerNetwork Engineer is an agent skill that packages senior cloud networking judgment for indie builders who own their own stack. It walks you through modern VPC and subnet design across AWS, Azure, and GCP, including gateways, peering, transit, load balancing, and service mesh considerations, with a strong bias toward secure, high-performance layouts rather than copy-paste console clicks. Use it when you are standing up networking for a new service, hardening access between tiers, or debugging latency and routing in production. The skill asks you to state goals, constraints, and inputs first, then applies checklisted best practices and verification steps so outcomes are actionable, not theoretical. It is guidance and architecture coaching—not a Terraform apply button—so you still implement changes in your cloud console or IaC. Open the implementation playbook when you need longer worked examples. Pair it with your IaC skills or security review workflows when changes touch production edges.442installs284Cpp ProCpp Pro is an agent skill that acts as a modern C++ implementation coach: clarify goals and constraints, then apply idiomatic patterns around RAII, smart pointers, move semantics, templates, and the STL while keeping exception-safety explicit. Solo builders touching native modules, game engines, high-throughput services, or CLI tools use it when naive pointer code or pre-C++11 style would create leaks, undefined behavior, or missed optimization opportunities. The skill steers toward stack allocation, const-correct interfaces, and measurement-driven tuning rather than premature micro-optimizations. Referenced implementation detail lives in an optional playbook resource when tasks need step-by-step examples. On Prism it signals a procedural coding workflow for agents that must output maintainable, standard-library-centric C++ rather than generic pseudocode.432installs285Database AdminDatabase-admin is a procedural agent skill that positions your coding assistant as a modern cloud database administrator. It is aimed at solo and indie builders who own their own Postgres, MySQL, or managed cloud databases without a dedicated DBA on call. Invoke it when you need goals clarified, constraints captured, and step-by-step guidance for provisioning, tuning, backups, replication, or security hardening across AWS, Azure, and Google Cloud patterns described in the skill body. The instructions emphasize validating outcomes and opening a detailed implementation playbook when you need worked examples rather than high-level advice. It fits after you have chosen a stack but before or during production cutover, and remains useful when incidents or growth force schema, index, or capacity changes. Pair it with your IaC and observability stack so recommendations become checklists you can execute and re-verify in the repo.1installs286Distributed Debugging Debug Tracedistributed-debugging-debug-trace is an implementation playbook skill that helps solo builders configure local and distributed-friendly debugging and tracing—starting with concrete VS Code launch profiles for Node.js and TypeScript. When intermittent bugs block ship, copying ad hoc inspect flags from blog posts wastes hours; this skill packages opinionated launch.json settings, source map resolution, and environment variables so your agent can apply them consistently across repos. It spans build and ship: you wire configs while implementing services, then rely on the same setups during review and regression. The readme positions it as a detailed companion to patterns and checklists rather than a single chat command, which suits indie backends and small microservice layouts heading toward production. Use it when you need integrated-terminal debugging, inspect breakpoints, and trace-oriented workflows instead of printf-only investigation.1installs287Django Access Reviewdjango-access-review is an agent skill for solo and indie builders shipping Django or Django REST Framework backends who need proof—not assumptions—about object-level authorization. Instead of scanning for canned anti-patterns, it drives an investigation: understand how this project enforces permissions, follow concrete request and queryset paths, and report only confirmed gaps where one principal could read or mutate another’s data. The workflow fits pre-release security passes, PR review on auth-sensitive endpoints, and tenant or B2B APIs where IDOR is the default failure mode. You install it when keywords like IDOR, access control, DRF viewsets, or object permissions show up in the task, and you want findings tied to traced code rather than generic checklists. It complements automated scanners by focusing on how your app actually answers authorization at runtime and in query construction.1installs288Django Perf ReviewDjango Performance Review is an agent skill for solo builders and small teams shipping Django APIs and SaaS backends who need evidence-backed performance audits instead of generic “optimize your ORM” chat advice. Invoke it when you are asked to review Django performance, find N+1 queries, optimize Django, check queryset performance, or audit database-driven bottlenecks. The workflow insists on researching the codebase first—tracing data flow, checking for existing optimizations, and validating data volume—before any issue lands in the report. Pattern matching alone never counts as proof. Findings roll up into impact categories with CRITICAL and HIGH reserved for problems that actually hurt at scale, and the skill explicitly permits a clean bill of health when nothing verifiable is wrong. That discipline matters for indie operators who cannot afford false alarms or rubber-stamp reviews before launch. Pair it with your normal ship checklist when ORM-heavy views, admin list pages, or serializers are in scope.1installs289Django ProDjango Pro is a community agent skill that acts as a Django 5.x expert for solo and indie builders shipping web applications and APIs. It is meant when you are doing Django-specific work—designing models and queries, choosing sync vs async views, structuring DRF endpoints, wiring Celery jobs, or adding Channels—and want goals, constraints, and verification spelled out instead of ad-hoc stack answers. The skill clarifies inputs, applies ecosystem best practices across the Django ORM, views, and common extensions, and returns actionable steps you can execute in your repo. It explicitly avoids unrelated domains and defers deep walkthroughs to the bundled implementation playbook when examples are needed. For Prism journey placement, treat it as backend-build first, with natural spillover into ship-time testing and operate-time deployment concerns that the description already names.1installs290Docs Architectdocs-architect is an agent skill for solo and indie builders who need trustworthy technical documentation without stopping feature work for weeks of writing. It treats documentation as architecture work: the agent analyzes repository structure, recurring patterns, and key implementation choices, then organizes that knowledge into comprehensive, long-form manuals suitable for onboarding, audits, or open-source contributors. Use it when a codebase has grown faster than its docs, when you are handing a module to a contractor, or when you want a durable reference that captures intent—not just API listings. The skill emphasizes clarity, system thinking, and documentation structure so readers can move from overview to deep detail. It is guidance-driven rather than a single fixed template, so you clarify goals and constraints first, then validate outcomes against how your stack actually behaves. For builders shipping SaaS, APIs, or internal tools with Claude Code, Cursor, or Codex, this skill reduces the tax of “tribal knowledge in chat logs” by turning the repo itself into the source of truth for prose.1installs291Docusign AutomationDocuSign Automation via Rube MCP teaches your agent to operate DocuSign through Composio’s toolkit: connect OAuth, search current tool schemas, then run template browsing, envelope creation, and signature management without hand-rolling REST clients. Solo builders shipping SaaS that needs NDAs, MSAs, or onboarding packets can keep signature logic inside the agent session while Composio handles auth and API surface drift. The skill stresses calling RUBE_SEARCH_TOOLS first so parameters match live schemas, then confirming an ACTIVE DocuSign connection before any send or manage action. Workflows are framed as ordered tool sequences with required versus optional steps, which fits indie teams automating contract sends from build pipelines or internal ops bots. Add https://rube.app/mcp as the MCP server endpoint—no separate Composio API key wiring in the skill text.1installs292Docx OfficialDOCX Official is an agent skill that embeds a structured tutorial for the popular docx JavaScript/TypeScript library so you can generate valid Microsoft Word files from code. Solo and indie builders use it when contracts, one-pagers, status reports, or customer-facing exports must land as real .docx—not screenshots or ad-hoc copy-paste. The skill stresses setup (global or project docx install), the Document → sections → children model, and saving via Packer.toBuffer or Packer.toBlob depending on runtime. It walks through text runs, paragraph-level layout, tables, images, headers and footers, hyperlinks, footnotes, and common pitfalls that corrupt files if you skip sections. Invoke when an agent task needs repeatable Word output from Node automation, CI artifacts, or internal tooling, and you want procedural knowledge inlined instead of guessing API shapes from scattered Stack Overflow threads.1installs293Domain Driven Designdomain-driven-design is a planning and routing skill for solo builders and small teams facing real business complexity—not generic CRUD. It forces a viability check so you do not pay DDD ceremony when rules are stable and integrations are simple. When warranted, it prioritizes strategic artifacts: subdomains, bounded contexts, and a shared language glossary before any tactical coding advice. A routing map sends the agent toward focused companion skills for strategic design, context mapping, and implementation patterns, and it frames when evented architectures like CQRS, event sourcing, sagas, or projections are justified from domain pressure rather than hype. Use it when multiple teams or fast-changing rules threaten model collisions, or when auditability and invariants matter. Skip it for localized bug fixes or when nobody can act as a domain proxy.1installs294Dotnet Architectdotnet-architect is a senior .NET backend architect skill for solo and indie builders shipping APIs and services on C# and ASP.NET Core. It packages language mastery, framework choices, data-access patterns, and cloud-oriented structure so your coding agent does not improvise enterprise shape from chat memory alone. Use it when you are scoping a new service, refactoring toward cleaner boundaries, or need checklists for async, LINQ, EF versus Dapper, and maintainable API design. The skill asks you to clarify goals and constraints first, then apply best practices with verifiable steps. It is aimed at builders who want production-grade decisions without a full platform team—whether you are on Claude Code, Cursor, or Codex inside an existing repo.1installs295Dotnet BackendThis skill provides expert guidance for building enterprise-grade ASP.NET Core backend services with Entity Framework Core, authentication, authorization, and background jobs. Use it when designing or refactoring APIs, implementing secure identity patterns, optimizing data access layers, or adding long-running services. It matters because solid backend architecture—with proper auth, performance, and reliability—directly enables SaaS platforms and APIs to scale safely.1installs296Drizzle Orm ExpertDrizzle ORM Expert is an agent skill for solo builders shipping TypeScript backends who want SQL-level control without losing compile-time safety. Drizzle compiles to raw SQL, which suits edge and serverless databases where heavier ORMs feel awkward. The skill covers defining schemas in code, expressing relational queries that read like SQL, running Drizzle Kit migrations safely across environments, and wiring the layer into common stacks such as Next.js App Router and tRPC or lightweight servers like Hono. It also addresses practical performance concerns—prepared statements, batching, and pooling—and helps when you are replacing Prisma or legacy ORMs. Reach for it when you are greenfielding persistence, modeling relations, debugging migration drift, or optimizing hot query paths in a small codebase you maintain alone.1installs297Dropbox Automationdropbox-automation is an agent skill that teaches your assistant to run Dropbox file operations through Rube MCP at https://rube.app/mcp and Composio’s Dropbox toolkit. Solo builders use it when deliverables, contracts, or media live in Dropbox but the agent otherwise cannot touch them without brittle custom scripts. The workflow always starts with RUBE_SEARCH_TOOLS for up-to-date schemas, then RUBE_MANAGE_CONNECTIONS to complete OAuth until the dropbox toolkit shows ACTIVE. From there you can search files and folders, continue paginated results, and chain upload, download, sharing, and folder management steps the SKILL.md enumerates. It is a build-phase integration skill—not a hosted Dropbox app—so you remain responsible for scopes, shared links, and what folders the connection can reach. Pair it with other Rube automation skills when your stack treats Dropbox as the system of record for assets.1installs298Dwarf Expertdwarf-expert is a deep technical agent skill for solo builders and systems-oriented indies who touch native toolchains, custom CLI utilities, or language runtimes where debug info quality determines whether you can trust stack traces and line tables. It encodes procedural knowledge about the DWARF standard versions 3 through 5: how to interpret DIE trees, common attribute patterns, and practical workflows with dwarfdump, readelf, and llvm-dwarfdump verification. Use it when you are writing or reviewing parsers, explaining why symbols vanished after a linker flag change, or producing examples of DWARF features for documentation in your repo. The skill deliberately stops short of v1/v2 archaeology, pure ELF layout tasks without debug sections, interactive debugger sessions, and reverse-engineering playbooks—those paths waste context and violate the documented when-not-to-use gates. For Prism’s audience shipping Rust, Go, or C++ CLIs, this is Ship-phase review work: validate artifacts before you publish binaries or integrate crash telemetry.1installs299Dx Optimizerdx-optimizer is a journey-wide Developer Experience specialist skill for solo and indie builders using AI coding agents. It structures how you reduce friction across onboarding, daily loops, and tooling: simplifying first-run setup, automating chores that eat context, tightening build and test cycles, and aligning editors, hooks, and small CLIs with how you actually work. The skill asks for goals and constraints up front, then applies checklists and validation steps drawn from its implementation playbook when examples are needed. Invoke it when spinning up a new repo, when every session starts with the same manual steps, or when collaborators flag slow feedback. It does not replace domain-specific infra skills; it optimizes the human-and-agent interface around your stack so shipping in build, hardening in ship, and iterating in operate all feel lighter.1installs300E2e TestingE2E Testing is an agent skill that walks solo builders through a structured Playwright end-to-end testing workflow. It targets anyone shipping a web app, API-backed UI, or internal tool who needs repeatable browser automation instead of manual click-throughs before merge or deploy. Use it when you are setting up E2E for the first time, automating regression on critical flows, adding visual regression checks, validating across Chromium/WebKit/Firefox, or wiring tests into CI so broken releases fail fast. The workflow moves from framework install and directory layout, through flow identification and page objects, to implemented specs you can run locally and in pipelines. It explicitly delegates deep Playwright mechanics and pattern catalogs to companion skills while keeping this bundle as the orchestration spine. For indie teams without a dedicated QA function, that spine turns scattered test advice into an ordered checklist you can hand to Claude Code, Cursor, or Codex in a repo that already has something worth protecting in production.1installs301Earllm BuildEarLLM Build is a phase-specific agent skill for solo developers maintaining EarLLM One, a Kotlin and Jetpack Compose Android app that links Bluetooth earbuds to a large language model through a voice pipeline. It activates when the conversation mentions earllm, earbud LLM apps, voice pipeline Kotlin, Bluetooth audio on Android, or SCO microphone behavior. The skill orients you to the multi-module layout, dependency direction, and the loop of capture, transcribe, infer, and speak—so agents do not treat the repo as a generic Compose starter. It is not for unrelated Android tasks or general chat without domain context; use a narrower tool when you only need a one-file snippet. Risk is marked safe in metadata, but you still own API keys, Bluetooth permissions, and on-device testing on real hardware.1installs302Electron DevelopmentElectron Development is an agent skill for solo and indie builders who need production-grade desktop apps, not fragile prototypes that leak Node into the renderer. It walks through Electron’s multi-process model—main, renderer, and preload—with emphasis on secure IPC, contextIsolation, preload scripts, and hardening choices that auditors and users expect. You get practical guidance for window lifecycle, native OS integration (menus, tray, notifications, file dialogs), and the packaging path via electron-builder or electron-forge, including code signing and auto-update with electron-updater. The skill also covers debugging main-process failures and renderer crashes, plus trimming bundle size when shipping to macOS, Windows, and Linux. Use it when desktop distribution is a requirement; skip it for browser-only SPAs, Tauri/Rust desktops, or Chrome extensions where a different stack applies.1installs303Elixir ProElixir Pro is a community agent skill from Antigravity Awesome Skills that positions the model as an Elixir expert for concurrent, fault-tolerant systems on the BEAM. Solo builders reach for it when scaffolding or refactoring OTP applications, designing supervision trees, or adding Phoenix LiveView channels without fighting the concurrency model. The skill steers toward pattern matching and guards instead of nested conditionals, process isolation for failure domains, and immutable state transitions that stay predictable under load. It calls out Ecto changesets for validation boundaries, Task/async flows for parallel work, and clustering considerations when you outgrow a single node. Testing guidance favors ExUnit plus property-based tests where invariants matter. When you need step-by-step recipes, the SKILL points to resources/implementation-playbook.md for deeper examples. It is intentionally narrow: unrelated domains should use a different skill. Complexity is advanced because OTP mental models and distributed Erlang assumptions are not beginner-friendly, but the instructions stay practical for indie teams shipping APIs and modest SaaS backends.1installs304Elon MuskElon Musk is an agent-building reference skill that loads a long-form technical dossier—primarily in Portuguese—so coding agents can emulate or cite a first-principles engineering persona when discussing rockets, EV platforms, neural interfaces, and tunneling ventures. Solo builders use it during Idea research when prototyping advisor bots, satirical or educational agents, or when stress-testing hardware-heavy product narratives against plausible specs instead of hand-wavy hype. It is not a workflow skill: there is no checklist gate, but the document is organized by venture with tables for Falcon 9 Block 5, Falcon Heavy, Starship development status, masses, propellants, and engine layouts. Multi-phase utility appears when the same corpus informs Validate scope conversations (what is technically feasible) or Build agent-tooling (persona system prompts). Treat knowledge cutoff and persona bias explicitly in production use. Intermediate complexity reflects reading dense specs, not implementing them.1installs305Emblemai Crypto WalletEmblemAI Crypto Wallet is an integration skill that teaches your coding agent to manage wallets through the EmblemAI Agent Hustle API instead of juggling separate SDKs for every chain. Solo builders shipping crypto dashboards, trading assistants, or treasury bots can standardize on one base URL and API-key header while still reaching Solana, Ethereum, Base, BSC, Polygon, Hedera, and Bitcoin with chain-appropriate operations. The documented surface includes balances, swaps, transfers, token lookup on Solana, and NFT reads on Ethereum, which maps cleanly to prototype-to-production agent features. Prism flags this package at critical risk because it moves real funds when misconfigured; treat keys, transaction previews, and user confirmation as non-negotiable guardrails. Install via the EmblemCompany skills bundle or the agentwallet npm package, then scope each invoke to explicit user intent for checks versus execution.1installs306Emotional Arc DesignerEmotional arc designer is a marketing methodology skill for solo builders who need landing pages, ads, email sequences, or product flows to move people through feelings on purpose—not a pile of disconnected claims. The agent acts as a narrative psychologist: it establishes who arrives, how they should feel at the end, what commitment you need, and channel constraints, then engineers a controllable emotional sequence rather than vague tone words. Use it in Validate when a landing narrative is still fluid, and again in Launch or Grow when distribution copy or lifecycle emails need the same disciplined arc. It fits indie founders writing their own funnel copy and small teams without a dedicated brand strategist. The workflow is consultative: if entry or exit emotion is unclear, the skill blocks until those are defined. Advanced complexity reflects psychology framing and ethical limits, not code. Outputs are structured arc maps you can hand to copywriters or implement in sections on a page.1installs307Energy ProcurementEnergy Procurement is a communication-templates skill for operators who must speak credibly to utilities, suppliers, and regulators about load, rates, and contracts. It is organized as ten on-demand document patterns—RFPs to energy suppliers, PPA term sheet responses, utility rate-case intervention comments, demand-response enrollment, budget forecast presentations, sustainability report energy sections, internal cost variance writeups, supplier renewal negotiation, regulatory filing comments, and board-level strategy summaries. Each template uses consistent {{variable}} placeholders so you substitute legal names, contacts, volumes, and dates without rebuilding structure from scratch. The skill is reference-tier documentation meant for compose-and-review workflows: pick the scenario, fill variables, align tone to the audience, then send or attach to filings. It does not bid markets or pull live tariff APIs; it gives solo operators and small ops teams enterprise-shaped language when energy spend is material to the business.1installs308Enhance PromptEnhance Prompt is an agent skill that acts as a Stitch Prompt Engineer for solo builders prototyping UIs with Google Stitch. It takes rough or failed UI prompts and runs a fixed pipeline: assess gaps (platform, page type, structure), sharpen specificity, add UI/UX keywords, align with your design system, and format output Stitch can use well. The skill points you to the official Stitch Effective Prompting Guide so practices stay current. It fits indie workflows where you iterate on screens before committing engineering time—especially when a vague prompt wasted a generation pass. Activate when polishing prompts, recovering from weak Stitch output, or turning a one-line idea into a structured landing page or dashboard brief.1installs309Telegram Automationtelegram-automation teaches your agent how to operate Telegram through Rube MCP and Composio’s Telegram toolkit—not raw HTTP guesses. Solo builders use it when a product or internal bot must notify users, post to chats, or share media from the same session that writes code. The skill enforces a safe sequence: confirm Rube is alive, search tools for fresh schemas, activate the Telegram connection, then run workflows like sending text with TELEGRAM_SEND_MESSAGE after optional chat verification. Prerequisites include a BotFather token and an ACTIVE connection link from RUBE_MANAGE_CONNECTIONS. Because community skills can carry elevated risk labels, treat tokens and chat IDs as secrets and prefer read-only verification steps before bulk sends. It fits agent-first backends and growth loops where Telegram is the notification channel.1installs310Uxui Principlesuxui-principles packages five community skills from the uxuiprinciples project so solo builders can audit interfaces with research-backed rigor instead of subjective taste. The set spans full principle evaluation (168 rules), antipattern smells, AI-specific interface review (44 principles), user-flow checks for decisions errors and feedback, and pre-code UX guidance for vibe coding sessions. Use it when you are about to ship a screen, reviewing an AI feature for trust and safety, or catching UX debt in an existing product description before your agent writes CSS. It fits builders using Claude, Cursor, or Windsurf who want consistent design language without hiring a UX team. The skills accept interface descriptions and flows rather than replacing your design tool, and they emphasize detectable issues and principle citations you can fix in the next iteration. That makes AI-generated UI less likely to violate accessibility, clarity, and AI transparency expectations.1installs311Wordpress Plugin Developmentwordpress-plugin-development is a structured agent workflow for solo builders shipping WordPress extensions without guessing how hooks, caps, and REST should fit together. It walks from plugin skeleton through admin experiences and API surfaces, emphasizing security and WordPress-native patterns instead of one-off PHP scripts. The catalog excerpt highlights WordPress 7.0-oriented capabilities—collaboration-ready meta, provider-agnostic AI prompts, agent-facing Abilities manifests, DataViews-style admin tables, and PHP-only block registration—so indie developers can align new plugins with platform direction rather than legacy list-table-only tutorials. Use it when you are turning a product idea into a distributable plugin, wiring automation for content or commerce sites, or exposing safe capabilities to external agents. It assumes comfort with PHP and the WordPress hook model; it is not a substitute for hosting hardening or full theme design.1installs