wshobson/agents
153 skills1M installs6M starsGitHub
Install
npx skills add https://github.com/wshobson/agentsSkills in this repo
1Typescript Advanced TypesTypeScript advanced types is a Build-phase reference skill for solo builders shipping SaaS, APIs, or CLIs who need compile-time guarantees beyond basics. It documents how to use generics with constraints, conditional and mapped types, template literal types, and built-in utility types to model libraries, form validation, configuration, and type-safe API clients. The material suits intermediate-to-advanced implementers implementing inference-heavy logic or tightening a JavaScript migration. Agents invoke it when the task explicitly calls for complex type utilities rather than everyday interface wiring. It is educational procedural knowledge—not a linter or codegen integration—so the deliverable is correctly applied patterns in your TypeScript source.46kinstalls2Tailwind Design SystemTailwind Design System is an agent skill for solo and indie builders who want a scalable UI foundation on Tailwind CSS v4. It walks through CSS-first configuration, design tokens, reusable component variants, responsive behavior, and accessibility so a small team does not accumulate one-off utility soup. Use it when you are starting a component library, aligning UI patterns across apps, implementing theming or dark mode with native CSS features, or migrating from Tailwind v3. The skill explicitly targets v4 (2024+) and maps common v3 patterns to v4 equivalents. It fits the Build phase when the product surface is taking shape and you need consistent primitives before ship-hardening and launch polish.45.9kinstalls3Nodejs Backend PatternsNode.js Backend Patterns is an agent skill for solo and indie builders who need production-shaped Node servers without reinventing middleware stacks on every project. It applies when you are creating REST or GraphQL APIs, microservices, real-time WebSocket features, or background workers, and want Express/Fastify conventions for errors, auth, and data layers spelled out in one place. The skill points you to structured guidance and worked examples in references/details.md when the navigation tier is too shallow. It emphasizes TypeScript, validated inputs, environment-based secrets, structured logging, rate limits, and HTTPS—choices that matter when one person owns deploy and on-call. Use it while scaffolding a new API or refactoring a fragile prototype into something you can ship and operate.34.6kinstalls4Python Performance OptimizationPython Performance Optimization is an agent skill that walks solo builders through profiling and fixing slow Python code using cProfile, memory profilers, and established performance practices. It fits indie hackers maintaining APIs, automation scripts, and data jobs where a single hot loop or N+1 query can tank response times. Use it when debugging unexplained latency, shrinking memory footprints, speeding CPU-heavy transforms, or tightening database and I/O paths before launch. The skill frames four profiling modalities and ties them to concrete metrics so you prioritize work by measured impact rather than guesswork. It complements Ship-phase testing and Operate-phase incident response without replacing dedicated load-testing infrastructure for high-traffic production fleets.25.6kinstalls5Brand LandingpageBrand Landingpage is an agent skill that implements a Brand Discovery Interview Framework for solo builders shipping product landing pages. It treats the conversation as the deliverable: you clarify project name, who the product serves, what action the page should drive, and brand/visual preferences before any layout or copy is generated. The framework assumes technical literacy—CTA, hex values, deploy—but bridges the gap into design language so agents do not default to interchangeable SaaS hero sections. Questions are phased (starting with Product & Purpose), limited to ten total across phases, and asked one at a time. When users paste existing docs, the skill mines them and skips covered ground; when users want to bypass discovery, it nudges them back because undirected generation duplicates page-builder output. Use it in Validate when defining a landing or pricing surface, and again in Build when refreshing brand-aligned frontend copy.25.4kinstalls6Python Testing PatternsPython Testing Patterns is an advanced agent reference for pytest-heavy solo backends and automation scripts. It goes past basic assert examples into async coroutine tests with @pytest.mark.asyncio, shared async fixtures, monkeypatching environment variables without touching real secrets, and patterns for temp files and conftest organization. The readme positions it explicitly as an advanced layer—property-based testing, database testing, and CI/CD wiring—so indie builders shipping APIs or CLIs can standardize how agents add tests. Invoke it when your suite is flaky on async code, when you need deterministic env isolation, or when you are preparing a GitHub Actions gate. It does not replace choosing a test framework; it encodes repeatable patterns the agent can paste and adapt. Confidence is high for Ship/testing placement with secondary use while implementing backend modules during Build.22.5kinstalls7Api Design Principlesapi-design-principles is a checklist-driven agent skill for solo builders shipping REST or HTTP JSON APIs who want fewer redesigns after the first client integrates. Before you scaffold routes or OpenAPI, the skill walks resource design (nouns, plural collections, shallow hierarchy), correct verb semantics, a full status-code matrix, and collection behaviors like pagination metadata, filters, and sorting. It also forces explicit choices on versioning and common failure modes so auth, validation, and rate limits read consistently to mobile apps, agents, and third parties. It is not a code generator—it is a design gate you run while scoping backend work and again before release when contracts change. Intermediate builders benefit most when they already know HTTP but lack a repeatable review ritual.22.1kinstalls8Code Review ExcellenceCode Review Excellence is a methodology skill for solo builders and tiny teams who still need professional review habits when merging their own work or reviewing contributors. It frames reviews as bug-finding, maintainability checks, and knowledge transfer—not ego displays or formatter wars. Core content covers when to invoke the skill (PRs, standards, mentoring, architecture passes, checklist design), principles for constructive comments, and clear boundaries about what reviews should not optimize for. The good-vs-bad feedback examples give agents a template for prioritized, actionable notes that respect the author. Because review touches implementation quality and release readiness, it stays anchored on Ship while remaining useful whenever code changes exist. Pair it with linters for style and with security or testing skills when comments need deeper verification. The outcome is faster, clearer review threads and shared standards that scale even when you are the only full-time engineer.21.7kinstalls9Nextjs App Router PatternsNext.js App Router Patterns is a reference skill for solo builders shipping SaaS or content sites on the App Router. It walks through concrete TypeScript examples: async page components that await searchParams, Suspense boundaries keyed to filter state, and server-side data fetching with Next.js cache tags. Use it when you are past prototype and need predictable structure for list/detail pages, loading UX, and environment-based API URLs—not when you are still choosing a framework. The patterns assume React Server Components as the default and keep interactive chrome in separate client components where needed. For indie teams, it reduces back-and-forth with agents by giving copy-pasteable page and component shapes that match current Next.js conventions (including Promise-wrapped searchParams). Pair it with interaction-design or a UI kit when you want polish; pair with backend or BFF skills when API contracts change.19.5kinstalls10Fastapi TemplatesFastAPI Templates is a backend agent skill for solo builders who want a disciplined starting tree instead of a single main.py spaghetti file. It prescribes a production-oriented layout under app/: versioned API routers and endpoints, centralized configuration and security, explicit database wiring, and clear boundaries between Pydantic schemas, ORM-style models, service-layer business logic, and repository data access. The skill targets async REST and microservice-style Python services backed by PostgreSQL or MongoDB, with hooks for middleware, dependency injection, and structured error handling. Use it when spinning up a greenfield API after validation, when refactoring an agent-built prototype into maintainable modules, or when you need your coding agent to repeat the same conventions across multiple services. It is a structural template—not a deployed platform—so you still choose hosting, auth providers, and CI, but you start from patterns that scale with team-of-one velocity.18.5kinstalls11Postgresql Table DesignPostgreSQL Table Design is an agent skill that walks solo builders through designing or reviewing Postgres-specific schemas with opinionated defaults and foot-gun warnings. It covers primary keys and identity columns, normalization versus selective denormalization, NOT NULL and DEFAULT usage, and indexes aligned to real query paths—including manual indexes on foreign keys. The skill emphasizes PostgreSQL-specific choices such as snake_case unquoted identifiers, nullable uniqueness behavior, TIMESTAMPTZ for events, and NUMERIC for money. Use it when starting a new service datastore, refactoring tables before a migration, or auditing an existing schema for redundancy and missing indexes. It fits indie SaaS and API products where one wrong type or missing FK index becomes production debt. The agent applies these rules as a checklist during design conversations rather than generating migrations blindly, helping you ship a schema that stays maintainable as features grow.18.5kinstalls12E2e Testing Patternse2e-testing-patterns is a procedural reference for solo and indie builders who want browser end-to-end tests that survive refactors and CI. It centers on Playwright with TypeScript: a production-style configuration spanning desktop and mobile browsers, reporters, and failure artifacts, plus a Page Object Model example that uses accessible selectors instead of brittle CSS. You reach for it when you are shipping a web app, SaaS dashboard, or API-backed UI and need copy-paste structure rather than one-off scripts scattered in chat. The patterns assume a local baseURL and standard npm workflows, which fits Claude Code, Cursor, and Codex agents extending an existing repo. It does not replace a full test strategy document—it accelerates consistent test layout so you can focus on critical user flows before launch.17kinstalls13Architecture Patternsarchitecture-patterns is a deep-reference agent skill for implementing serious backend structure: Domain-Driven Design bounded contexts, onion layers, anti-corruption layers, and realistic multi-service directory trees. Indie builders often start with a monolith route file; this skill gives Codex or Claude Code a shared blueprint—domain entities and value objects, use cases, adapter repositories, infrastructure services—so refactors stay intentional instead of accidental. The e-commerce style example spans identity and catalog services with pytest-friendly layout. Use when Validate scope has outgrown a single repo, when Build backend needs clear module seams for agents to edit safely, or when Operate infra requires services that deploy independently. It is reference material cited from a parent SKILL.md, not a codegen shortcut: expect to adapt names and boundaries to your actual product. Advanced readers gain ACL patterns when talking to payments, ERP, or third-party APIs without polluting core domain models.16.7kinstalls14Mobile Ios DesignMobile iOS Design is an agent skill that encodes Apple Human Interface Guidelines patterns as copy-ready SwiftUI structure for solo iOS developers. It documents standard and list-row padding, safe area insets for persistent bottom actions, and adaptive grids that respond to horizontal size class. Builders use it when screens feel cramped, violate margin conventions, or break on iPad width without a second layout pass. The skill stays at the presentation layer—no networking or navigation deep dives—so it pairs well with feature work where visual polish and HIG compliance determine App Store perception. Agents apply it to keep spacing, materials, and button prominence consistent across scrollable content and confirmation flows.16.2kinstalls15Mobile Android Designmobile-android-design is an agent skill that guides solo builders through Google Material Design 3 (Material You) and Jetpack Compose when designing and implementing native Android interfaces. Use it when you need consistent M3 components, Navigation Compose, dynamic theming, or layouts that adapt across phones, tablets, and foldables—not when you only need backend APIs or iOS SwiftUI. The skill encodes ecosystem conventions (FABs, chips, sheets, lists) so agent-generated Kotlin UI stays aligned with platform expectations rather than generic web-style markup. It fits indie builders shipping Play Store apps who want procedural reminders on accessibility, screen configurations, and Compose layout primitives without rereading the full Material docs each sprint. Invoke during active UI implementation in the build phase; pair with your own design tokens and app architecture skills for end-to-end delivery.15.9kinstalls16Prompt Engineering PatternsPrompt Engineering Patterns teaches advanced techniques to make LLM calls reliable in production: few-shot example selection, chain-of-thought and tree-of-thought reasoning, dynamic demonstrations, structured JSON outputs, and systematic prompt debugging. Solo builders shipping agent features, SaaS copilots, or internal automation use it when outputs drift, context is tight, or templates need to scale across tasks. The skill emphasizes controllability—balancing example count with window limits, retrieving examples from knowledge bases, and refining system prompts for specialized assistants. It applies during Build when authoring agent skills, during Ship when hardening review or test prompts, and during Grow when tuning customer-facing AI copy. It is methodology and pattern reference, not a single integration; pair it with your stack’s actual model API and eval habits.15.2kinstalls17Error Handling Patternserror-handling-patterns is an agent skill for mastering how failures surface across languages and architectures so solo builders ship software that degrades gracefully instead of opaque stack traces. It frames core philosophies—exceptions that interrupt control flow versus explicit Result types for expected validation failures—and maps error categories from network timeouts and rate limits to unrecoverable programming mistakes. Use it when adding features, shaping public APIs, debugging production behavior, or adopting retry and circuit-breaker tactics for async and distributed calls. The readme positions the skill for reliability work and better messages for both end users and developers, which spans writing new backend paths in Build, hardening before release in Ship, and interpreting failures in Operate. It is procedural reference material, not a linter or observability product; pair it with your stack’s native error types and logging.14.9kinstalls18Javascript Testing PatternsJavaScript Testing Patterns is an agent skill for solo and indie builders who need production-grade test coverage in JavaScript and TypeScript codebases. It walks through choosing and configuring Jest or Vitest, structuring unit and integration tests, mocking dependencies, and exercising frontend components with Testing Library. You reach for it when bootstrapping test infrastructure on a greenfield app, backfilling coverage before a launch, or teaching your coding agent to follow TDD instead of one-off scripts. The skill emphasizes realistic thresholds, async testing, and CI integration so tests actually gate merges rather than rotting in a folder. It pairs naturally with code-review and security skills in the Ship phase but also supports Validate prototypes that need a quick spec suite before you commit to a full build.14.2kinstalls19Sql Optimization PatternsSQL Optimization Patterns is an intermediate agent skill for solo builders and small teams who own application databases end to end. It teaches a repeatable workflow: capture slow queries, run EXPLAIN ANALYZE with the statistics that matter, interpret scan types and join behavior, then apply indexing, query rewrite, and schema adjustments to cut latency and database load. The skill fits when debugging production-grade slowness, designing new tables before traffic arrives, or chasing response-time regressions after a feature ship. It emphasizes PostgreSQL examples but the mental model transfers to other engines that expose plan output. You should invoke it whenever the database shows up in profiling, not only during emergencies—early index design prevents expensive rewrites later. Outcomes include faster endpoints, lower cloud database bills, and fewer opaque ORM-generated queries. It complements application-level caching skills but does not replace measurement; always validate with ANALYZE and real row counts.14kinstalls20Modern Javascript PatternsModern JavaScript Patterns is an agent skill that encodes a structured guide to ES6 and later language features and common functional-style habits for everyday app code. Solo and indie builders install it when they want an agent to stop guessing syntax—async/await versus Promises, destructuring, spread, modules, iterators, generators—and to apply consistent patterns during refactors or greenfield UI and client logic. The SKILL.md positions it for refactoring legacy scripts, implementing functional transformations, optimizing hot paths, and migrating callback-heavy code to modern async models. It fits the Build phase first (frontend and full-stack JavaScript), and remains useful in Ship when performance or review-driven cleanup targets JavaScript quality. Complexity sits at intermediate: you should already read JavaScript comfortably; the skill accelerates correct modern choices rather than teaching programming from zero.13.9kinstalls21Security Requirement ExtractionSecurity Requirement Extraction is an agent skill that supplies templates and worked examples for modeling security requirements as structured Python dataclasses. Solo and indie builders shipping SaaS, APIs, or agent-backed products use it when they need to translate vague “make it secure” goals into enumerated requirements across authentication, authorization, data protection, cryptography, session management, audit logging, and related domains. Each requirement can carry acceptance criteria, test cases, threat references, and compliance framework links so later review and testing have something concrete to verify against. The skill fits early journey work when you are scoping what must be true before writing auth or infra code, and again when you are preparing ship-phase security reviews against OWASP or SOC2-style expectations. It is editorial and structural rather than a live scanner: you instantiate the models in your repo or docs and iterate with your agent. Use it when compliance framing or threat-informed backlog items are missing from your validate or ship checklists.13.6kinstalls22Dotnet Backend Patternsdotnet-backend-patterns is a reference skill for solo and indie builders shipping on Claude Code, Cursor, or Codex who need a consistent C#/.NET playbook instead of one-off snippets. It walks through Clean Architecture project structure, application services and DTOs, infrastructure repositories with EF Core or Dapper, and hosting patterns suited to REST Web APIs and MCP servers. The material emphasizes modern async patterns, constructor-based dependency injection, the IOptions configuration style, caching with Redis or memory caches, and testing with xUnit so agents do not skip integration coverage. Invoke it when you are scaffolding a new backend, refactoring toward layered boundaries, or reviewing C# for performance and maintainability before merge. It pairs well with ship-phase review habits but stays anchored on implementation depth rather than distribution or analytics.13.6kinstalls23Rust Async PatternsRust Async Patterns is a procedural agent skill for solo builders who write network services, CLIs, or backend crates with Tokio. It walks through the lazy Future execution model, when to use async fn and await, and how runtimes schedule work via Wakers—so you stop fighting mysterious Pending loops. The guide ties together tokio with futures, async-trait for dyn-safe APIs, anyhow for ergonomic errors, and tracing for observability in concurrent code. Use it when you are implementing async I/O, designing multi-task pipelines, or diagnosing deadlocks and cancellation bugs before Ship. It is reference-heavy rather than a one-click generator: you apply patterns inside your existing Cargo workspace. Intermediate Rust familiarity helps; the skill assumes you already chose Rust for performance-sensitive backend work.13.5kinstalls24Python Design PatternsPython Design Patterns is an agent skill that teaches maintainable structure for solo and indie builders writing Python: keep solutions simple until complexity is justified, give each unit one reason to change, and prefer composing objects over deep inheritance hierarchies. Install it when you are sketching a new service, splitting a monolithic function, debating whether a new abstraction pays for itself, or reviewing a teammate’s PR for structural smell. It pairs naturally with test-driven work because entangled I/O and domain rules are called out as a primary anti-pattern. The skill is methodology, not a code generator—you still write the modules, but the agent steers naming, boundaries, and layering consistently. Expect intermediate familiarity with Python packages and pytest-style testing. Use during Build for implementation choices and again in Ship when reviewing merges that touch architecture.12.7kinstalls25Git Advanced Workflowsgit-advanced-workflows is a procedural agent skill that walks solo and indie builders through high-leverage Git operations that rarely fit in a quick commit message cheat sheet. It documents four practical flows: cleaning a feature branch with interactive rebase and force-with-lease before a pull request, propagating a critical fix with cherry-pick across release branches, narrowing regressions with bisect (manual steps or bisect run against a test command), and using worktrees to handle a hotfix lane alongside normal development. The skill is aimed at builders who already use Git daily but want consistent, copy-paste-safe patterns when history quality, multi-version maintenance, or parallel checkouts block velocity. It fits the Prism journey when you are in Build shipping integration work or in Ship preparing reviewable diffs and traceable fixes—not as a substitute for basic clone/commit/push fluency.12.5kinstalls26Database MigrationDatabase Migration is an agent skill package of Sequelize-oriented patterns and templates for solo and indie builders who own their own Postgres or MySQL stack. It focuses on practical DDL workflows: adding columns safely, backfilling in batches, and removing obsolete fields only after traffic has moved. The standout material is a zero-downtime, blue-green style sequence split into multiple migration phases so you can deploy application code between steps instead of betting everything on a single maintenance window. It also documents cross-dialect differences when the same migration must run on more than one engine. Use it when you are planning a schema change for a live SaaS or API, refactoring identifiers like email columns, or porting tables between databases. It complements generic ORM docs by encoding opinionated rollout ordering that reduces downtime risk for small teams without a dedicated DBA.12.5kinstalls27Responsive DesignResponsive-design is an agent skill package that teaches breakpoint strategies for solo builders shipping web and hybrid apps with modern CSS. It centers on mobile-first baselines, then layers min-width enhancements so phones load lean styles while tablets and desktops gain layout upgrades. The guidance contrasts device-chasing breakpoints with content-driven cut points where typography, navigation, or grids actually break. Reference sections map common scales from Tailwind CSS and Bootstrap 5 so agents emit consistent sm/md/lg/xl tiers in generated stylesheets or component libraries. Use it while scaffolding landing pages, dashboards, or marketing sites when you want the coding agent to default to performant, progressively enhanced layouts instead of desktop-only CSS that gets patched later. It fits Claude Code, Cursor, and similar agents during frontend implementation passes, pairing naturally with design tokens and component frameworks without replacing a full design system skill.12.2kinstalls28Openapi Spec GenerationOpenAPI Spec Generation is a wshobson agents skill focused on code-first OpenAPI: derive specifications from FastAPI and TypeScript stacks, tighten them with validation and linting, and use the contract for SDK generation. Indie builders shipping REST or JSON APIs benefit when they want the spec to stay truthful to implementation instead of drifting in a separate YAML file. The readme walks through FastAPI app configuration, Pydantic models with Field descriptions, enums, pagination queries, and server metadata—patterns that map directly to solo SaaS backends and internal tools. Use it in Build while defining routes and models; revisit in Ship when contract tests or client SDKs need a stable surface. It complements documentation and testing skills but stays firmly in API backend territory rather than frontend or pure SEO work.11.5kinstalls29Async Python Patternsasync-python-patterns is an agent skill that teaches asyncio through detailed, runnable examples—async context managers, async generators, paginated fetch loops, and related concurrency idioms. It is aimed at solo and indie builders shipping Python APIs, CLI tools, or agent backends who already know Python but want correct non-blocking I/O instead of trial-and-error in chat. Use it during implementation when you are wiring database sessions, HTTP clients, websockets, or background tasks and need patterns that avoid leaked connections, blocking the event loop, or messy cancellation. The skill emphasizes procedural knowledge you can drop into a repo rather than one-off snippets, so your coding agent produces maintainable async code. It fits the Build phase backend workstream and pairs well with FastAPI, aiohttp, and async ORM stacks. Complexity is intermediate to advanced because it assumes familiarity with coroutines and error handling in async code.11.4kinstalls30Solidity Securitysolidity-security is an agent skill for indie Web3 builders and small teams shipping EVM smart contracts who need concrete insecure-vs-secure patterns instead of vague “be careful” advice. It focuses on critical vulnerability classes—starting with reentrancy where an attacker re-enters before balances are cleared—and teaches the Checks-Effects-Interactions discipline: update state before external value transfers. The skill includes copy-pasteable VulnerableBank and SecureBank examples plus an OpenZeppelin ReentrancyGuard variant so agents can refactor withdrawals and similar interaction-heavy functions during implementation or pre-launch review. Use it when drafting new protocol code, fixing audit findings, or having an agent sanity-check a PR that uses low-level calls. It does not replace professional audit or formal verification but steers day-to-day coding toward mainstream secure defaults.11.3kinstalls31Backtesting Frameworksbacktesting-frameworks is a Finance & Trading agent skill that walks solo and indie builders through implementing event-driven strategy backtests in Python. It is for anyone validating algo or discretionary rules on historical data before wiring live brokers or scaling infrastructure. The skill emphasizes concrete patterns: typed orders and fills, position accounting with average cost and realized PnL, and dataframe-friendly loops suitable for agent-assisted coding in Claude Code, Cursor, or Codex. Use it when you have entry/exit logic on paper but need a reproducible simulation with commissions and slippage hooks, not when you only need charting or one-off spreadsheet math. It complements broader agent repos by giving procedural scaffolding rather than a black-box library recommendation, so your agent can extend the templates into your own data pipeline and risk checks.11.2kinstalls32Terraform Module LibraryTerraform Module Library is a reference skill for solo and indie builders who need production-shaped AWS and Oracle Cloud Infrastructure stacks without spending days reverse-engineering module boundaries. It walks through composable patterns for virtual networks, Kubernetes, relational databases, object storage, load balancers, serverless functions, and security groups, plus OCI VCN equivalents with gateway and routing attachments. The embedded best-practices list pushes encryption by default, KMS, backup strategies, GuardDuty and Security Hub awareness, and consistent resource tagging—decisions that matter when you are the only person on call. Use it while you are still defining architecture in Validate or when you are wiring CI deploy pipelines in Build, then keep it open during Operate when you extend subnets, replicas, or listener rules. It is procedural knowledge for your coding agent, not a live Terraform registry; you still own state backends, environments, and drift checks.11.1kinstalls33Github Actions TemplatesGitHub-actions-templates is an agent skill that gives solo builders copy-ready GitHub Actions YAML for continuous integration and deployment. It documents when to automate testing, image builds, cluster deploys, security scans, and multi-environment matrix jobs, then supplies concrete workflow skeletons such as a Node test pipeline with cached dependencies, lint, unit tests, and coverage upload. The skill fits indie teams shipping SaaS, APIs, or CLIs who want opinionated patterns instead of reading Actions docs from scratch. Primary placement is Ship/testing because the flagship example is a test job, but the same templates support launch prep and operate infra when you wire deploy stages. Invoke when setting up CI/CD with GitHub Actions or creating reusable workflow templates for your monorepo or service repo.11kinstalls34K8s Security Policiesk8s-security-policies is a template skill for solo builders and tiny teams running workloads on Kubernetes who need sensible network segmentation without hiring a platform engineer. It ships copy-paste NetworkPolicy manifests starting from default deny all ingress and egress, then layers the essentials most clusters forget: cluster DNS egress, frontend-to-backend TCP paths, ingress controller reachability, and monitoring scrape paths. Each template uses standard networking.k8s.io/v1 resources with placeholder namespaces and label selectors you replace for your app. The workflow assumes you adopt deny-by-default first, then selectively punch holes—matching how production security reviews expect zero-trust pod networking. Use it when your agent is drafting ship checklists or generating namespace-scoped policy bundles alongside your Deployment manifests.10.6kinstalls35Gdpr Data HandlingGDPR Data Handling is a security-focused agent skill that gives solo builders concrete implementation patterns for consent management under GDPR-style requirements. Rather than abstract legal bullets, it walks through data models that capture purpose-specific consent, timestamps, privacy policy version, and technical proof such as IP address and user agent. A ConsentManager-style service shows how to record grants and withdrawals, maintain an audit log, and emit events so email, analytics, and product subsystems stay in sync when users change their minds. Indie SaaS and API builders use it while wiring signup flows, cookie banners, and preference centers, and again when operating production systems that must honor erasure and access requests. It does not replace legal counsel or a full DPIA, but it shortens the path from “we need GDPR” to auditable code structures your agent can extend across PostgreSQL, MongoDB, or similar stores.10.4kinstalls36Design System Patternsdesign-system-patterns is an agent skill for solo builders creating scalable UI foundations across web and mobile. Use it when you need design tokens, semantic naming, theme providers, and component-library structure—not one-off page CSS. The skill fits early Validate prototypes that should look production-grade, the Build phase where tokens and themes are wired into React (or similar) apps, and Launch/Grow moments when multi-brand or dark-mode polish affects perceived quality. It documents how to separate primitive colors and spacing from semantic roles like text-primary or surface-elevated, how to implement dynamic theme switching with storage and OS preference, and how to keep component APIs predictable for agents generating new screens. Intermediate complexity: you should understand basic CSS variables or RN theming. Outcome is a coherent token hierarchy and theming infrastructure agents can reuse instead of inventing new hex codes per file.10.2kinstalls37React Native Designreact-native-design is an agent skill that teaches solo builders how to structure React Native UIs with StyleSheet, dynamic style arrays, and flexbox layouts in TypeScript. It is for indie developers shipping iOS and Android apps with Claude Code, Cursor, or similar agents when screens feel ad hoc or inconsistent across components. Invoke it while implementing lists, cards, navigation chrome, or responsive layouts during the build phase—not when you only need backend APIs or store listing copy. The skill walks through container padding, font weights, line heights, primary/secondary variants, and opacity-based disabled states so agents generate maintainable style objects instead of inline magic numbers. Pair it with a design-system skill if you need tokens and themes; use this one when you want concrete RN styling recipes and layout idioms that match platform expectations and keep components readable for future refactors.10.1kinstalls38React Native ArchitectureReact Native Architecture is an agent skill for solo builders shipping cross-platform mobile apps with Expo and Expo Router. It lives in the Build phase because it turns product navigation decisions into concrete file-based routes, tab shells, and dynamic segments instead of leaving agents to guess React Navigation wiring. The readme walks through patterns such as a themed tab layout with Home, Search, Profile, and Settings screens, icon tinting from design tokens, and parameterized profile routes using `useLocalSearchParams`. Use it when you are laying down the skeleton of an indie app—before you wire APIs or ship to stores—so Claude Code, Cursor, or Codex generates consistent `app/` structure and TypeScript screen options. It is reference architecture, not a one-click deploy: pair it with your state, auth, and testing skills as the app grows.10kinstalls39Godot Gdscript PatternsGodot GDScript Patterns is an agent skill aimed at solo indie game developers who need production-shaped Godot 4 code instead of one-off script snippets. The excerpted material centers on advanced scene management: an autoload SceneManager that emits loading lifecycle signals, supports optional transition scenes, and uses ResourceLoader threaded requests with progress polling before swapping the current scene. Builders invoke it when they are implementing level flow, menus, or async content loads and want consistent GDScript structure. The skill positions itself as part of a numbered pattern library spanning save systems, performance, and broader best practices beyond the scene excerpt. It fits small teams shipping Godot titles who want the agent to follow established autoload and signal conventions rather than inventing fragile scene-change logic each sprint.9.8kinstalls40Monorepo ManagementMonorepo Management is a reference-heavy agent skill that teaches procedural patterns for pnpm workspaces and Nx monorepos—where packages live, how to add dependencies with filters, and how to run dev, build, and test across the graph. Indie builders shipping a SaaS plus shared UI library or CLI tools use it when a single-repo multi-package layout is cheaper than many repos but tooling flags feel opaque. The readme walks through pnpm-workspace.yaml conventions, .npmrc tuning for peers and hoisting, and Nx generators for React, Next, and JS libraries with nx.json task defaults. It does not replace your CI vendor docs but gives copy-paste command shapes agents can apply while scaffolding or refactoring. Canonical placement is Build/pm because structure choices precede feature work; the same patterns resurface in Ship when wiring affected builds and in Operate when bumping dependencies repo-wide.9.7kinstalls41React State Managementreact-state-management is an agent skill for solo and indie builders who ship React frontends with Claude Code, Cursor, Codex, or similar tools and need repeatable state patterns instead of one-off chat snippets. It documents production-oriented Redux Toolkit with TypeScript: configuring the store, defining slices with async thunks, and exporting typed dispatch and selector hooks so components stay type-safe as the app grows. Use it during the build phase when you are wiring global or feature state for dashboards, carts, auth session data, or multi-view SaaS UIs where props drilling or ad-hoc context becomes painful. The readme walks through concrete file layouts (store index, user slice) that agents can mirror across features. It complements generic React component skills by focusing on data flow, loading and error states, and maintainable slice boundaries—helping you avoid inconsistent patterns across PRs when you are the only developer on the project.9.7kinstalls42Uv Package ManagerUV Package Manager is an advanced reference skill for Astral’s uv toolchain, aimed at solo Python builders who want one fast path from pyproject.toml to tested, containerized deploys. The excerpted readme emphasizes monorepo workspaces, GitHub Actions with setup-uv caching, and slim Docker images that install the uv binary and sync locked deps before copying application code—patterns indie API and SaaS backends adopt early to avoid “works on my laptop” pip entropy. It sits at intermediate complexity: you should already have a repo and tests, then layer uv sync, uv run, and optional all-extras dev groups. On Prism’s journey it is multi-phase: primary build/backend for local envs, secondary ship/testing and ship/launch via CI workflows, and operate when you maintain lockfile upgrades. Unlike a thin cheat sheet, the skill documents numbered patterns (12–14+) spanning monorepo, CI/CD, and Docker, making it cite-worthy for long-tail “how do I run pytest with uv in Actions” queries.9.6kinstalls43Accessibility ComplianceAccessibility Compliance is an agent skill that guides implementation and remediation of inclusive interfaces aligned with WCAG 2.2. Solo builders shipping SaaS, extensions, or mobile web cannot afford lawsuits, app-store rejection, or silent exclusion of keyboard and screen-reader users. The skill activates when you are auditing accessibility, adding ARIA to interactive components, hardening forms, or supporting platform assistive technologies. It covers the four WCAG principles, concrete ARIA patterns, focus behavior, motion and contrast preferences, and mobile reader considerations. Use it during frontend implementation and again as a structured review pass before launch. It does not replace manual testing with real assistive devices but gives agents a consistent checklist to reduce violations and document fixes.9.6kinstalls44Kpi Dashboard Designkpi-dashboard-design is an agent skill that helps solo builders and small teams design KPI dashboards with realistic department taxonomies instead of a single vanity chart. It walks through common sales, marketing, product, and finance metrics—recurring revenue, pipeline health, acquisition costs, engagement, satisfaction, margins, and cash indicators—and connects them to layout thinking for executive or functional views. Use it when you have product telemetry or spreadsheets but no coherent dashboard story for weekly reviews, investor updates, or growth experiments. The skill is reference and template oriented: it informs which tiles belong together and how to phrase metric definitions for agents or BI tools, rather than wiring a specific vendor. Pair it with your analytics stack implementation in Build or Grow once you know which KPIs matter for your stage.9.4kinstalls45Architecture Decision RecordsArchitecture Decision Records is a journey-wide documentation skill for solo builders and small teams who need disciplined records of why a stack or pattern was chosen—not just what shipped. It teaches when an ADR earns a file versus when a changelog entry is enough, and structures each record around context, the decision itself, and downstream consequences. The lifecycle covers proposed through accepted, deprecated, superseded, or rejected states so agents and humans can trace evolving architecture without re-litigating settled choices. Use it when adopting a new framework, picking a database, defining API shapes, or documenting security and integration boundaries. It pairs naturally with planning and review work across Build and Ship because the same ADR corpus accelerates onboarding and makes refactors safer when you can see the original constraints.9.4kinstalls46Stripe IntegrationStripe-integration is a procedural agent skill that encodes Stripe payment implementation patterns for solo and indie builders shipping SaaS, APIs, or e-commerce backends. It focuses on practical Checkout Session creation for one-time charges, including hosted flows and Elements-oriented sessions with custom UI mode, with Python examples that show line items, metadata, and structured error handling. Use it when your agent is implementing or refactoring billing in the build phase and you want consistent API usage instead of improvising from scattered docs. The skill does not replace Stripe’s full documentation for webhooks, Connect, or compliance, but it gives a fast, copy-adaptable starting point for the most common checkout paths. Pair it with your stack’s framework docs and your own webhook skill or server routes so payments stay aligned with order and user records in your database.9.4kinstalls47Rag Implementationrag-implementation is an agent skill for solo builders adding semantic search and grounded answers to products. It documents advanced retrieval patterns—hybrid keyword and embedding search with ensemble weights, multi-query expansion, and LLM-based contextual compression—using LangChain-oriented code sketches. Use it in Build when designing agent memory, support bots, or internal knowledge tools, and in Validate prototype when proving recall on messy document corpora. The skill emphasizes composable retrievers rather than a single vector index dump. It suits indie hackers who already have chunks and embeddings but need higher precision and less noisy context in the prompt.9.1kinstalls48Interaction DesignInteraction Design is a procedural skill for solo builders who want UI that feels finished: microinteractions, motion timing, loading and skeleton states, notifications, gestures, and scroll-driven polish. It is framed around purposeful motion—confirming actions, preserving context, and directing attention—rather than animation for its own sake. Invoke it when an MVP works but feels flat, when you need consistent duration and easing across modals and page changes, or when agents default to instant state jumps without feedback. The skill spans implementation detail (CSS easing, duration buckets) and product judgment (when 200ms vs 400ms is appropriate). It complements visual design systems and Next or React component skills; it does not replace accessibility review or performance budgets. Because interaction quality affects conversion and support load, many teams reuse it again at Ship and Launch when tightening onboarding and landing flows.9.1kinstalls49Python Code Stylepython-code-style is a journey-wide agent skill for solo builders maintaining Python codebases with modern tooling instead of ad-hoc formatting debates. It encodes when to reach for automated formatters, how to align naming with PEP 8, and why public APIs should carry type annotations and accurate docstrings. The quick start centers ruff and mypy configuration you can drop into pyproject.toml, which fits indie repos that cannot afford a dedicated platform team. Use it while scaffolding a new service, tightening CI, or reviewing a contributor PR. On Prism it reads as procedural quality knowledge—compatible with Claude Code, Cursor, and Codex whenever Python clarity and lint hygiene matter, from first module through production fixes.9.1kinstalls50Changelog AutomationChangelog Automation is an agent skill for solo and indie builders who ship software on a regular cadence and want release notes that stay honest without manual copy-paste. It encodes the Keep a Changelog format—Unreleased bucket, dated releases, and compare URLs—alongside a practical mapping from Conventional Commits types into Added, Changed, Fixed, Removed, Security, and Deprecated sections. Semantic versioning rules clarify when to bump MAJOR versus MINOR versus PATCH, including breaking changes via feat! or BREAKING CHANGE footers. Use it when you are cutting a version, preparing GitHub Releases, or syncing marketing copy with what actually merged. The skill is prose-first patterns and worked examples rather than a single vendor CLI, so your agent drafts or normalizes CHANGELOG.md from git history and commit conventions you already use. It fits Claude Code, Cursor, and Codex workflows where release hygiene competes with feature work.8.9kinstalls51Langchain ArchitectureLangchain Architecture is an agent skill aimed at solo builders shipping LLM-powered products who need opinionated patterns instead of endless framework docs. It focuses on composing LangGraph state machines for retrieval-augmented generation: typed graph state, async retrieve and generate nodes, embedding-backed vector stores, and prompt templates that force answers to cite retrieved context. Use it when you are past the Validate sketch and actively building backends or agent services that must orchestrate models, tools, and memory. The skill fits indie teams wiring Claude or other chat models to Pinecone or similar indexes without hiring an ML platform team. Expect Python-centric examples you can adapt to your observability and deployment stack in later Ship and Operate phases.8.9kinstalls52Deployment Pipeline DesignDeployment pipeline design is an agent skill for solo builders shipping containerized or registry-based apps through mature CI/CD. This repository entry is the advanced reference layer: platform-specific YAML, extended rollback strategies, and production-grade GitHub Actions patterns while core strategy tables live in the parent SKILL.md. Expect guidance on triggering production from main or manual dispatch, least-privilege permissions with id-token for OIDC to cloud providers, Docker metadata tagging by short SHA, and build caching to keep indie deploy cycles fast. Use when you are moving from ad-hoc deploy scripts to a repeatable production pipeline, or when you need reusable workflows across services. Intermediate complexity assumes a repo, container story, and a target registry. Pair with testing and security review skills before exposing the pipeline to main-branch auto-deploy.8.9kinstalls53Debugging StrategiesDebugging Strategies is a journey-wide agent skill that turns bug hunting from guesswork into a methodical ritual solo builders can reuse on every stack. It frames investigation around the scientific method—observe real behavior, form hypotheses, run focused experiments, analyze outcomes, and iterate until the root cause is proven. The SKILL.md stresses mindset guardrails: never dismiss plausible causes, always seek reproducible steps, isolate variables, and take notes when you are stuck. Rubber duck debugging and phased workflows (beginning with reliable reproduction) give structure whether you are in local dev, pre-release hardening, or production firefighting. Scope explicitly includes performance issues, unfamiliar codebases, crash dumps, profiling, memory leaks, and distributed systems—so it is not tied to one language or framework. Install it when unexpected behavior appears anywhere in the solo-builder journey, not only after deploy.8.8kinstalls54Microservices PatternsMicroservices Patterns is an agent skill for solo and indie builders who outgrew a single deployable and need clear service boundaries. It teaches decomposition by business capability—illustrated with e-commerce Order, Payment, and Inventory services—and shows how each service owns its lifecycle while communicating through domain events on an event bus. Async Python-style examples cover creating orders, charging payments, and reserving stock without collapsing everything into one codebase. Use it when you are designing backend topology, defining service APIs, or planning event-driven handoffs between teams-of-one wearing multiple hats. The readme points to a broader pattern library and worked examples for cases beyond the snippet. It assumes you will operationalize discovery, idempotency, and failure handling in later ship and operate work; this skill focuses on structural patterns and illustrative code paths rather than a full platform checklist.8.7kinstalls55Web Component DesignWeb Component Design is an agent skill that teaches solo builders how to structure modern UI with React, Vue, and Svelte using reusable patterns instead of one-off page code. It walks through compound components for related controls, render props for data-driven rendering, and slot-style injection in Vue and Svelte, alongside practical CSS-in-JS and styling tradeoffs. The skill fits when you are standing up a small design system, hardening component APIs before a team grows, or replacing brittle legacy widgets with composable pieces. It stresses accessibility and responsive behavior as defaults, not polish passes, so agents do not generate pretty but unmaintainable trees. Invoke it during Build when screenshots or wireframes exist but implementation consistency is missing—especially for SaaS dashboards, browser extensions, and hybrid mobile shells that share components.8.6kinstalls56Auth Implementation PatternsAuth Implementation Patterns is an agent skill that packages battle-tested authentication snippets for solo and indie builders shipping Node/Express APIs. It lives on the build backend shelf because you invoke it while implementing login, session continuity, and protected routes, but the same patterns matter during ship when you harden token storage and error handling before launch. The readme walks through JWT structure, generating access and refresh tokens with distinct secrets and lifetimes, verifying payloads, and gating requests with middleware—exactly the repetitive glue agents often get wrong on first pass. Use it when you have a greenfield or early SaaS API and need consistent 401 behavior, not when you are only evaluating Auth0 versus Clerk without writing code. After patterns are in place, run your security review skill or checklist before production. Pair with env-secret discipline; the skill assumes JWT_SECRET and JWT_REFRESH_SECRET are configured.8.6kinstalls57Python Project Structurepython-project-structure is a procedural skill for designing maintainable Python trees: src layout, domain folders like services and models, pyproject.toml alignment, and explicit public surfaces via __all__. Solo builders reach for it when starting a CLI, API, or agent tool repo, or when a flat scripts folder has become unmaintainable. It emphasizes shallow hierarchies, consistent naming, and discoverable modules so agents and humans know what is public versus internal. The quick-start tree and pattern sections give copyable structure instead of debating where tests live. It pairs naturally with later testing and packaging work but stops at architecture—implementation details still live in your application code.8.5kinstalls58Grafana DashboardsGrafana Dashboards is an agent skill that walks solo and indie builders through designing and implementing production-ready Grafana dashboards for applications, infrastructure, and business metrics. It encodes hierarchy-of-information layout, the RED method for request-serving components, and the USE method for resource saturation, with concrete JSON structure for an API monitoring dashboard. Use it when you already collect Prometheus metrics and need a repeatable panel recipe instead of improvising every graph. It fits builders who ship small SaaS or APIs and cannot afford a dedicated SRE but still want SLO-oriented views and refresh-friendly operational boards. The skill emphasizes tags, timezone, and refresh defaults suitable for real ops workflows rather than demo snapshots.8.4kinstalls59Gitlab Ci Patternsgitlab-ci-patterns is a reference skill for solo builders and small teams standardizing delivery on GitLab. It documents how to structure .gitlab-ci.yml with clear stages, reusable variables, Docker-based jobs, and practical optimizations like dependency caching and short-lived build artifacts. The included Node 20 example walks through npm ci, build output preservation, lint and test with coverage reporting, and a production deploy step that applies Kubernetes manifests and waits on rollout—patterns you can adapt to your stack. Use it when you are implementing or tuning GitLab CI/CD, wiring GitLab Runners, or connecting pipelines to Kubernetes and GitOps flows. It is pattern documentation for agents to generate or refactor pipelines, not a hosted runner service; you still own secrets, runner capacity, and cluster credentials in GitLab variables.8.4kinstalls60Visual Design FoundationsVisual Design Foundations is a reference-style agent skill for solo builders implementing interfaces who need disciplined color systems instead of ad hoc picks. It emphasizes perceptually uniform scales using OKLCH in CSS, with concrete variable naming from 50 through 950 and a primary anchor at 500. For teams preferring classic HSL generation, it documents a TypeScript-friendly `generateColorScale` pattern that maps lightness stops to named steps, then applies the same approach to semantic hues for success, warning, and error states. The skill fits the moment you are wiring globals, Tailwind extensions, or component themes during Build—not when you are still debating product scope. Agents can paste and adapt these patterns into your stack without claiming to replace accessibility review or full brand strategy. Treat it as the numerical backbone under typography and spacing skills elsewhere in the catalog: consistent ramps reduce contrast surprises and make dark-mode extensions more predictable for one-person shipping cadences.8.3kinstalls61Secrets ManagementSecrets Management is a procedural agent skill from the wshobson agents collection that walks solo builders through storing and rotating sensitive values in CI/CD. Instead of copying DATABASE_URL into GitHub Secrets ad hoc, the skill compares Vault, AWS Secrets Manager, Azure Key Vault, and Google Secret Manager and shows concrete setup snippets—dev Vault server, kv put paths, and GitHub workflow integration patterns implied in the truncated readme. It targets indie SaaS and API teams who are one leak away from a incident because `.env` files drifted into git. Complexity sits at intermediate: you need a cloud or Vault endpoint and comfort with IAM. On the Prism journey it spans ship security (primary), build integrations when you first connect staging, and operate infra when rotation schedules fire. Deliverables are architectural choices plus copy-paste commands for pipelines that fetch secrets at runtime rather than baking them into images.8.3kinstalls62Python Packagingpython-packaging walks solo builders through modern Python distribution from first folder layout to wheels on PyPI. It explains why src-layout is usually safer, how pyproject.toml replaces scattered setup files under current PEPs, and how to pick a build backend for libraries versus slim CLI utilities. The skill spans metadata, classifiers, versioning discipline, editable installs for local dogfooding, and the difference between wheels and source distributions—topics that matter when an agent otherwise generates a broken pyproject or non-installable tree. Use it while you are creating a reusable package, wiring a command-line entry point, or preparing a release candidate, then revisit the same guidance at ship time for build commands and upload checks. It is procedural reference material, not a one-click publisher: you still need credentials policy and review before any public index push.8.3kinstalls63React Modernizationreact-modernization is an agent skill package for solo and indie builders who maintain React apps that still use class components, legacy lifecycles, or pre-17 import styles. Instead of hand-editing hundreds of files, you run documented jscodeshift commands against your tree, optionally with --dry and --print to audit diffs safely. The material spans rename-unsafe-lifecycles, update-react-imports, error-boundary insertion, TSX parser usage, and hook-oriented codemods from the ecosystem. It also sketches how to author custom transforms when setState-to-useState migration needs project-specific rules. Use it during intentional frontend upgrades after you have scoped the target React version, not as a substitute for test coverage. The outcome is a repeatable codemod playbook your coding agent can invoke while you review git diffs and run your test suite in Ship.8.2kinstalls64Python Error Handlingpython-error-handling is an agent skill that encodes detailed Python error-handling patterns for solo builders shipping APIs, CLIs, and automation. It emphasizes custom exception hierarchies that carry HTTP status, response bodies, and retry metadata so callers can branch without parsing strings. Examples include ApiError and RateLimitError with structured constructors and a match-based handle_response flow for common client status codes from 200 through 5xx. Use it while implementing new endpoints, wrapping third-party HTTP APIs, or refactoring catch-all except blocks into explicit failure modes. It complements general debugging skills by front-loading design at the boundary layer rather than post-mortem log triage. Intermediate Python with typing familiarity is assumed.8kinstalls65Workflow Orchestration Patternsworkflow-orchestration-patterns is reference material for solo builders and small teams adopting durable execution engines such as Temporal. It explains why orchestration logic lives in workflows that cannot call external systems directly, while all non-deterministic side effects belong in short-lived, idempotent activities. The guide walks through a concrete design decision tree, saga-style compensation, and worked examples so agents do not collapse HTTP calls and business branching into one undifferentiated script. Use it when you are implementing payments, provisioning, or multi-step approvals that must survive worker crashes and redeploys. The content is advanced backend architecture; it assumes you are already committing to a workflow runtime rather than cron-plus-queue glue.7.9kinstalls66Startup Financial ModelingStartup Financial Modeling is an agent skill that walks solo founders through a structured financial model: clarify business model and pricing, project revenue with cohorts and retention, layer fixed and variable costs, and tie headcount plans to fully loaded compensation. It is written for indie SaaS and marketplace builders who need investor-ready or founder-ready spreadsheets logic without hiring a FP&A team first. The documented SaaS retention benchmarks and marketplace take-rate framing help you stress-test whether CAC payback and expansion assumptions are plausible during validation—not after launch. Use it when you are choosing pricing tiers, annual vs monthly mix, or hiring velocity, and want the agent to keep assumptions explicit across revenue and cost blocks. It complements prototype and landing work by answering whether the opportunity can carry real operating costs at your target scale.7.9kinstalls67Python Anti PatternsPython Anti-Patterns is an agent skill that gives solo builders a negative checklist: what not to do in Python before code ships or while you chase odd production behavior. It is explicitly for reviewing implementations before finalizing them, debugging issues that might come from known bad practices, teaching best practices, and refactoring legacy modules. The SKILL.md organizes guidance into thematic anti-pattern areas such as infrastructure mistakes like duplicating timeout and retry logic across every HTTP call instead of centralizing retries in decorators or shared clients. The skill does not teach full system design—that is left to companion positive-pattern skills—but it catches foot-guns early when you are moving fast with an agent writing most of your backend. Use it during Ship review, during Build when iterating on integrations, and during Operate when incidents smell like swallowed exceptions or retry storms. Confidence is high because frontmatter and body spell out triggers and examples clearly.7.8kinstalls68Memory Safety PatternsMemory Safety Patterns is an agent skill that distills cross-language techniques for writing systems code without classic memory failures. Solo builders shipping CLIs, native extensions, or backend services in Rust, C++, or C can use it when managing files, sockets, or heap allocations and when choosing how much safety to buy versus raw control. The skill frames preventable bug categories, compares prevention strategies (RAII, smart pointers, bounds checking, Sync), and situates Rust’s ownership model on a spectrum next to C++ and garbage-collected stacks. It fits the Build phase for new implementation and often reappears in Ship and Operate when you are reviewing unsafe blocks, chasing leaks, or deciding whether a hot path should stay in C or move to Rust.7.8kinstalls69Wcag Audit Patternswcag-audit-patterns is an agent skill that packages detailed Web Content Accessibility Guidelines audit checklists and worked examples for solo and indie builders shipping web products. It is aimed at developers and designers who want consistent, criterion-by-criterion reviews instead of vague “make it accessible” prompts. Use it when you are polishing marketing pages, SaaS dashboards, or content sites and need the agent to verify alt text, media alternatives, semantic structure, and form labeling against common Level A expectations. The skill emphasizes concrete HTML patterns—decorative images with empty alt, charts with meaningful descriptions, proper heading stacks, and tables with scoped headers—so findings map directly to fixes. It fits the Prism journey as a multi-phase checker: validate landing copy and structure, harden frontend during build, and re-run before ship and launch. Pair it with your UI stack skills and treat outputs as a structured defect list for remediation, not a substitute for manual testing with assistive technology or formal compliance sign-off.7.8kinstalls70Llm EvaluationLLM Evaluation is an agent skill for implementing end-to-end evaluation strategies on AI products you ship as a solo builder. It walks through automated scores for generation, classification, and RAG retrieval, complements them with human judgment and experiments, and emphasizes baselines so you notice regressions when prompts, models, or retrieval changes. Use it when your agent feature works in dev but you cannot explain quality, when you compare two model providers, or when you need confidence before enabling a workflow for paying users. The canonical home is Ship testing, but it equally supports Build agent-tooling when you design eval harnesses alongside prompts and tools. It does not replace observability stacks; it gives you the measurement design so monitoring and iteration have numbers and protocols behind them.7.7kinstalls71Bash Defensive Patternsbash-defensive-patterns is an agent skill that teaches solo builders how to write and review Bash scripts using strict mode, traps, quoting discipline, and safe array handling. It centers on enabling set -Eeuo pipefail at the top of scripts so errors, unset variables, and pipeline failures surface immediately instead of corrupting later steps. The readme walks through ERR traps that report line numbers, EXIT traps that remove temporary directories, and the difference between unsafe unquoted cp $source $dest and quoted paths. It also covers declaring arrays, iterating with "${items[@]}", loading command output via mapfile and readarray, and using [[ ]] for Bash-native conditionals. Invoke it whenever you author or refactor shell used in Claude Code hooks, Cursor tasks, Codex sandboxes, or your own CI and deploy scripts—especially before shipping scripts that touch production paths or secrets. The skill is procedural knowledge, not a running service; you apply the patterns directly in .sh files and in code review comments.7.7kinstalls72Unity Ecs PatternsUnity ECS Patterns is an agent skill that teaches data-oriented game architecture for solo and indie builders shipping performance-sensitive Unity titles. It walks through defining pure-data components, tag markers, internal buffer elements, and shared team identifiers, then wiring Burst-friendly ISystem implementations with explicit update requirements and delta-time movement logic. The readme emphasizes the recommended ISystem path over legacy patterns so agents generate code that compiles under Burst and scales with entity counts. Use it when you are past the prototype stage and need consistent ECS scaffolding for combat stats, targeting, inventories, or team grouping rather than one-off MonoBehaviour scripts. It matters for Prism’s build-phase shelf because many game skills stop at editor workflows while this one anchors simulation structure—the layer that determines frame cost and multiplayer readiness before you enter ship-phase profiling and optimization passes.7.7kinstalls73Cost OptimizationCloud Cost Optimization is an agent skill for solo builders and indie teams paying real money across AWS, Azure, GCP, and OCI. It combines a concrete tagging standard—Environment, Owner, CostCenter, Project, ManagedBy—with provider-specific guidance so Cost Explorer, CUR, management groups, and compartment chargeback actually work. Use it when you need to reduce cloud spending, right-size VMs and managed services, implement governance policies, or compare spend across clouds. The skill emphasizes publishing an approved tag dictionary, enforcing tags via policy and CI, inheriting tags from shared modules, and auditing inconsistencies weekly. It is intentionally operational: maintain performance and reliability while optimizing. It pairs well with Terraform, OpenTofu, or Pulumi workflows referenced under ManagedBy. Expect finance-aligned vocabulary (cost centers) and cross-cloud parity, not a single-vendor cheat sheet.7.5kinstalls74Helm Chart ScaffoldingHelm Chart Scaffolding is an agent skill that walks solo and indie builders through creating, organizing, and validating Helm charts for Kubernetes. It targets the moment you need to template deployments, package applications for distribution, or standardize configs across dev, staging, and production without copy-pasting YAML. The skill covers chart layout, values comments, helper templates, dependency versions, and pre-package validation aligned with Helm conventions. Use it when you are new to Helm, refactoring raw manifests into a chart, or setting up a chart repository for internal or client deliverables. It complements agent-driven backend work by turning application definitions into installable, versioned release units operators can upgrade with helm upgrade.7.5kinstalls75Protocol Reverse EngineeringProtocol Reverse Engineering is an agent skill that walks solo builders through capturing, filtering, and analyzing network traffic using industry-standard tooling. It covers Wireshark and tcpdump for PCAP collection, mitmproxy and Burp for HTTP/HTTPS interception, and analysis patterns for dissecting unknown or proprietary protocols. The skill targets indie developers shipping APIs, integrations, or clients who need evidence-based debugging rather than guessing from logs alone. Use it when traffic does not match documentation, when you must document a custom wire format, or when validating security-sensitive communication before launch. Complexity is advanced: you need comfort with shells, interfaces, and capture filters. It complements generic debugging skills by focusing on the network layer as the source of truth for what bytes actually crossed the wire.7.5kinstalls76Python Type Safetypython-type-safety packages advanced Python typing recipes your agent can paste into backend code when plain annotations are not enough. It walks through generic repository interfaces that separate entity types from identifier types, async method contracts, and bounded TypeVars tied to Pydantic models so validation stays linked to static types. Solo builders shipping FastAPI or async Postgres services use it to keep repositories and DTO layers consistent as schemas evolve, reducing mypy surprises and review churn. The skill is example-heavy rather than a linter wrapper—you still run mypy or pyright in CI, but the agent gets idiomatic patterns for generics that are easy to get wrong alone. It fits the build phase when you are hardening APIs and data access, and it remains useful during ship review when you tighten types before release.7.5kinstalls77Embedding Strategiesembedding-strategies gives solo builders and their agents ready-made Python patterns for calling major embedding providers instead of reinventing clients on every RAG experiment. It foregrounds Voyage AI—with models tuned for code, finance, and legal copy—and OpenAI’s embedding APIs with practical batching for long corpora. You reach for it when you are wiring semantic search, agent memory, or classification features and need consistent `embed_documents` versus `embed_query` handling, environment-based API keys, and sensible defaults. The skill is template-heavy rather than a full vector database playbook, so you still choose storage and chunking elsewhere. It suits indie SaaS and agent products where retrieval quality hinges on picking the right model family early and not leaking keys into prompts.7.5kinstalls78Gitops WorkflowGitops-workflow is an agent skill that walks solo builders and small teams through ArgoCD installation and first-run configuration on Kubernetes. It covers kubectl-based standard and high-availability installs, Helm-based deployment into an argocd namespace, and practical steps to reach the UI via port-forward plus initial admin credentials. The skill continues into production-shaped concerns: Ingress for argocd-server with Let's Encrypt-style TLS annotations and nginx passthrough, plus CLI login workflows for ongoing sync and app management. Use it when you are moving from manual kubectl applies to declarative GitOps, when you need a repeatable cluster bootstrap for staging or production, or when your agent should generate copy-paste-ready YAML and shell commands rather than improvising fragile one-off deploy scripts. It fits builders shipping SaaS, APIs, or internal services on Kubernetes who want git to drive what ships.7.4kinstalls79Go Concurrency Patternsgo-concurrency-patterns is a Go-focused agent skill that teaches reusable concurrency layouts for solo and indie builders shipping APIs, CLIs, or background workers. The readme centers on a worker pool: jobs flow through a channel, a configurable number of workers process each job under a shared context, results return on a buffered channel, and a WaitGroup plus dedicated closer goroutine ensures channels shut down cleanly after work finishes. Use it when you are in the build phase and need bounded parallelism, cooperative cancellation, or a template to adapt instead of one-off goroutine spikes that are hard to test or operate. The skill is procedural knowledge rather than an MCP integration: your agent applies the pattern to your package layout, error handling, and observability hooks. It matters because getting shutdown and backpressure wrong is a common source of stuck goroutines and memory pressure in small Go codebases.7.3kinstalls80Market Sizing AnalysisMarket Sizing Analysis is an agent skill that teaches solo and indie builders how to quantify opportunity using TAM, SAM, and SOM—not vague “big market” claims. It centers a complete bottom-up workflow: define ICP segments by revenue band, count addressable companies, assign annual contract value, and roll up total addressable market with cited public data sources. A full SaaS walkthrough (AI-powered email marketing for e-commerce) shows how to layer small, mid-market, and enterprise segments, prioritize wedges, and sanity-check against top-down industry stats. Use it when you are still in discovery: comparing niches, pitching cofounders, or deciding whether a vertical deserves a landing page and prototype. The output is spreadsheet-ready logic and narrative you can reuse in validate-phase scope and pricing conversations without inventing install counts or star ratings.7.3kinstalls81Context Driven DevelopmentContext-Driven Development provides artifact templates for Conductor context files that solo builders use when kicking off or re-scoping a product. Instead of improvising README-shaped notes, you copy structured product.md and tech-stack.md outlines covering problem statements, target users, feature status, success metrics, technology choices, infrastructure, and dev tooling. The skill is editorial scaffolding: it does not run commands or enforce a methodology by itself, but it standardizes what “context” means for downstream agent sessions. It is most valuable when you are validating scope or standing up PM discipline early, and it remains useful in Build when updating stack or roadmap tables as the product evolves.7.2kinstalls82Memory ForensicsMemory forensics is an agent skill that walks solo builders and small teams through Volatility 3 command recipes for Windows memory images: installation, symbol paths, process trees, hidden process scans, network artifacts, loaded modules, and common injection heuristics. It targets operators who received a raw dump from a laptop, VM, or compromised server and need a repeatable plugin order instead of guessing Volatility syntax. Primary placement is Ship security for breach assessment and readiness drills, with strong overlap in Operate when responding to live incidents that require offline RAM analysis. The content assumes you legally hold the image and can run Python-based tooling locally. It complements disk and log forensics but does not replace chain-of-custody procedures or enterprise IR retainers.7.2kinstalls83Data Quality Frameworksdata-quality-frameworks is an agent skill for solo builders and small data teams who want repeatable validation beyond ad-hoc SQL spot checks. It walks through Great Expectations patterns: composing named suites, asserting column sets, enforcing primary and foreign key constraints, and validating categorical domains on tables such as orders. The included Python module structure shows how to register multiple expectation configurations in one suite so agents generate consistent, reviewable quality code instead of one-off asserts. Use it when shipping analytics features, ETL jobs, or internal dashboards where silent data drift breaks trust. It complements application unit tests by treating tables as contracts. Intermediate comfort with Python and a GE runtime in your project helps; the skill does not replace orchestration choices (Airflow, dbt tests, etc.) but gives concrete expectation types to encode business rules.7.2kinstalls84K8s Manifest Generatork8s-manifest-generator is an agent skill that helps solo builders and small teams turn deployment intent into production-minded Kubernetes YAML. It walks through Deployments for workload shape, Services for networking, ConfigMaps and Secrets for configuration, and PersistentVolumeClaims when state matters—all while nudging you toward resource requests and limits, liveness and readiness probes, and pod security contexts that clusters expect in real environments. Invoke it when you are tired of copying brittle snippets that omit limits or leak secrets into plain ConfigMaps. The skill summarizes best practices inline and points to references/details.md for extended patterns when your cluster layout is non-trivial. It fits the Ship phase for indie SaaS, APIs, and internal tools you deploy with kubectl, GitOps, or a managed Kubernetes offering. It does not replace a full platform team runbook, but it compresses the first 80% of manifest drafting so you can review, diff, and promote manifests across staging and production with confidence.7.2kinstalls85Startup Metrics FrameworkStartup Metrics Framework is an agent skill that teaches solo and indie builders how to pick, calculate, and benchmark the KPIs investors expect at each funding stage. It walks through universal revenue metrics (MRR, ARR, growth rates), unit economics (CAC, LTV, fully loaded acquisition cost), and cash-efficiency signals that matter when you are still one person wearing product, sales, and ops hats. Use it when you are scoping pricing and packaging, standing up a first metrics dictionary, sanity-checking whether growth is efficient, or preparing a board or investor update without a full finance team. The skill is prose-and-formula reference material your agent can turn into spreadsheets, Notion dashboards, or narrative in a data room. It does not replace a billing system or analytics product—it gives you the vocabulary and targets so whatever stack you use reports the right numbers.7.2kinstalls86Dependency Upgradedependency-upgrade is an agent skill for solo and indie builders who need a disciplined playbook when package.json drift turns into framework majors, audit failures, or mysterious peer conflicts. It walks through semantic versioning rules, inventory commands across npm and yarn, and tree analysis so you know what you are actually shipping before you merge. The skill is meant for upgrading major framework versions, patching security-vulnerable libraries, modernizing stale stacks, resolving dependency conflicts, planning incremental paths, testing compatibility matrices, and automating routine updates. Instead of bumping versions in chat and hoping CI passes, you get compatibility analysis, staged rollout framing, and comprehensive testing emphasis aligned with real monorepo and app maintenance. Use it when a major version is on the roadmap, when npm audit blocks release, or when yarn why shows duplicate transitive packages you cannot explain.7.1kinstalls87Competitive LandscapeCompetitive Landscape is an agent skill that coaches your AI through rigorous market rivalry analysis using Porter's Five Forces, Blue Ocean Strategy, and positioning maps. Solo builders use it when a problem space feels crowded, when pricing power is unclear, or when a deck needs a defensible “why us” story without hand-wavy competitor lists. The skill pushes structured questions—barriers to entry, switching costs, network effects, supplier power—so outputs read like strategy homework an associate would turn in, not a bullet salad from a web search. It is tagged primarily under Idea → Competitors because that is where you first decide whether the wedge is real, but the same analysis resurfaces during Validate when scoping an MVP and Launch when tuning messaging against alternatives. Intermediate complexity: you should name real competitors and segments. It does not fetch live financials; you bring the market facts and the skill enforces framework completeness.7.1kinstalls88Cqrs ImplementationCqrs Implementation is an agent skill for the build phase that supplies copy-ready Python templates for Command Query Responsibility Segregation on the write path. Solo builders shipping order, inventory, or billing APIs can use it to standardize dataclass commands, UUID and timestamp metadata, handler registration, and async dispatch through a small command bus—reducing one-off service spaghetti. The readme centers Template 1: command infrastructure with extensible handler map and typed generics, illustrated with e-commerce order lifecycles. It does not replace event sourcing or read-model design docs; it accelerates the command side so agents can add validation, persistence, and domain rules consistently. Intermediate complexity assumes comfort with async Python and domain-driven boundaries. Use when splitting reads and writes or when multiple command types need a single entrypoint. Follow with testing and review skills before ship, and pair with API layer skills for HTTP exposure.7.1kinstalls89Billing Automationbilling-automation is an agent skill that encodes detailed subscription billing patterns for indie and solo builders shipping SaaS or API products. It walks through a concrete Python subscription type with lifecycle states, trial handling, activation after trial, and past-due transitions so you are not guessing how to align billing periods with real calendar quirks like billing cycle day. Use it when you are in Build and need backend logic that matches how customers actually move from trial to paid, fail payments, pause, or cancel—not when you only need a pricing landing page. The skill emphasizes worked examples and copy-pasteable structure rather than a single vendor SDK, which helps if you are comparing processors or layering your own entitlements on top. It matters because botched subscription state is a churn and support tax; getting trials, renewals, and dunning hooks consistent early saves rework before Ship and Grow.7.1kinstalls90Temporal Python Testingtemporal-python-testing is an agent skill that teaches integration testing patterns for Temporal Python workflows using mocked activities. It is aimed at solo and indie builders who orchestrate durable work with Temporal and want confidence in branching, retries, and activity calls without wiring every external dependency in CI. The documented flow centers on WorkflowEnvironment, an async Worker that swaps real activities for mocks, and pytest-driven workflow execution that asserts both return values and that the right activities ran. That separation keeps tests fast and deterministic while still exercising workflow logic. Use it when you are hardening ship readiness for event-driven backends, workers, or agent pipelines built on Temporal, and when you need a repeatable template before you add error-injection cases. It does not replace unit tests on activity implementations or end-to-end tests against real sandboxes.7.1kinstalls91Dbt Transformation Patternsdbt-transformation-patterns is a procedural agent skill that teaches repeatable dbt project structure for solo and indie builders who own the data stack end to end. It documents how to declare sources with loader metadata and freshness windows, build thin staging models that standardize ids and strings, and attach schema tests so bad loads fail before they reach marts. The readme walks through Stripe-style examples—customers, payments, relationship keys—so you can copy patterns instead of inventing folder conventions on every greenfield warehouse. Use it when you are standing up analytics for a SaaS product, wiring Fivetran or similar EL into dbt, or refactoring a messy SQL repo into staging and mart layers. It matters because untested transforms silently poison dashboards and agent-generated SQL; dbt patterns give your coding agent a consistent vocabulary for sources, CTE chains, and test blocks. Pair with your warehouse adapter docs and CI that runs dbt test on every PR.7.1kinstalls92Python Configurationpython-configuration is an agent skill that helps solo builders replace fragile os.environ reads with typed, validated Pydantic Settings models. Worked examples cover automatic coercion for booleans and integers, parsing comma-separated ALLOWED_HOSTS-style variables into lists, and layering an Environment enum so log levels and feature flags switch cleanly between local, staging, and production. The skill fits early backend scaffolding and refactors when a growing Python API, worker, or agent runtime has config scattered across modules. It emphasizes explicit Field aliases matching deployment env var names operators already use in Docker, Fly, or Railway. You get maintainable settings objects that fail fast at startup instead of silent misconfiguration. Pair it with python-resilience when retry limits and API endpoints live in the same settings module. Complexity is intermediate: you should understand Python typing and basic twelve-factor env configuration.7.1kinstalls93Airflow Dag PatternsAirflow Dag Patterns is an agent skill that packages Apache Airflow 2.0+ TaskFlow API conventions and a full daily ETL example for solo builders shipping data pipelines. It targets indie teams who need repeatable DAG structure—decorator-based tasks, S3-backed extract and load paths, pandas transforms, and explicit task chains—without piecing together docs from scratch. Use it when you are implementing scheduled batch jobs, warehouse loads, or analytics prep during the build phase, especially if your agent already knows Python but needs opinionated DAG layout. The readme emphasizes passing structured dicts between tasks, row counts for validation, and lightweight post-load notify steps. It complements generic DevOps skills by focusing on in-DAG Python patterns rather than cluster provisioning. Pair with infra skills for deployment, then testing skills before promoting DAGs to production schedules.7.1kinstalls94Python ObservabilityPython Observability teaches solo builders how to make FastAPI-style Python services legible in production using Prometheus instrumentation patterns rather than flying blind on logs alone. The skill walks through defining Histogram buckets for latency, Counters for request and error rates, and Gauges for saturation such as database pool usage—then wiring those into endpoint handlers via decorators. It is most often used when you are past prototype and need Operate-grade visibility, but the same snippets land during Build when you scaffold middleware and metrics registries. For indie API and SaaS stacks, this procedural knowledge keeps agents from inventing incompatible metric names or missing error labels on every route. Intermediate Python and async HTTP familiarity help; you still need a Prometheus scrape target or compatible stack to consume the metrics.7.1kinstalls95Risk Metrics Calculationrisk-metrics-calculation is an agent skill for solo and indie builders implementing quantitative risk in Python fintech, trading bots, or portfolio side projects. It documents a Core Risk Metrics pattern: a RiskMetrics class that accepts periodic returns and an annual risk-free rate, then computes standard volatility (with optional annualization), downside deviation relative to a threshold, and beta versus a market return series after alignment and dropna. The patterns lean on pandas, numpy, and scipy—appropriate when you already have return history and need correct annualization (√252) and defensive handling when downside samples are empty or beta inputs are too short. Use it during backend implementation or when hardening analytics pipelines before ship, not as a substitute for compliance review or live market data ingestion. Intermediate complexity: comfort with return series semantics and basic portfolio statistics is assumed.7.1kinstalls96Event Store Designevent-store-design is a template-heavy agent skill for solo builders shipping SaaS or APIs who want event sourcing on PostgreSQL without reading entire CQRS treatises first. It packages production-shaped DDL—events with stream metadata and monotonic versions, global_position for catch-up subscribers, JSONB event_data and metadata, plus snapshots and subscription checkpoint tables—and points to a Python implementation sketch for append, concurrency, and read-side replay. Use it when you have decided on event sourcing or audit logs as the source of truth and need consistent naming and indexing before writing domain handlers. The skill does not replace operational runbooks for retention, encryption, or multi-region replication; it accelerates the first correct schema and client boundaries so your agent can generate repositories, projectors, and tests in the same repo. Intermediate complexity: you should understand idempotency, optimistic concurrency on stream version, and why snapshots exist.7kinstalls97Threat Mitigation Mappingthreat-mitigation-mapping is an agent skill that gives solo builders and small teams a structured way to connect identified threats to concrete security controls instead of listing vague “we use HTTPS” bullets. It provides dataclass-oriented templates for controls typed as preventive, detective, or corrective, placed at layers from network to process, and scored by implementation status and effectiveness. Use it during Ship when you are hardening a SaaS or API before launch, or when you need a traceable map for investor, enterprise, or compliance conversations—not as a substitute for a full penetration test. The worked examples emphasize coverage scoring and relationships between threats, dependencies, and technologies so you can prioritize partial implementations. For indie products, this skill turns scattered security todos into an auditable mitigation model you can iterate in Operate as controls move from partial to verified.7kinstalls98Stride Analysis Patternsstride-analysis-patterns is an agent skill that supplies STRIDE threat-modeling templates and partial worked examples for solo and indie builders shipping web apps, APIs, or agent backends. It walks you through system overview, data-flow narration, trust boundaries, a sensitivity-ranked asset table, and six STRIDE buckets—each with tabular threats (ID, target, impact, likelihood) plus mitigation checklists. The bundled excerpt demonstrates Spoofing (session hijacking, JWT forgery, credential stuffing) and Tampering (e.g., SQL injection) so your agent can extend the same pattern to Repudiation, Information disclosure, Denial of service, and Elevation of privilege. Use it when you have an architecture sketch but no written threat model before code review, pen-test prep, or compliance conversations. It is documentation-first: you get repeatable structure, not automated scanning—ideal for pairing with architecture docs during Validate scope and revisiting during Operate when boundaries change.7kinstalls99Web3 TestingWeb3 Testing is an agent skill for solo builders and small teams shipping Solidity smart contracts and DeFi-style protocols who need industrial test harnesses without hiring a dedicated blockchain QA lead. It centers on Hardhat and Foundry: compiler settings, forked mainnet networks at pinned block heights, multi-network configs, gas reporting in USD, and coverage plugins wired through environment variables for RPC keys and private deploy keys. The skill maps when to write unit versus integration tests, when to fuzz edge cases, and how to validate behavior against realistic chain state before users touch real funds. Invoke it while drafting test files, configuring `hardhat.config.js`, or standing up automated coverage for a protocol upgrade. Solid automated tests reduce redeploy risk and make ship-phase security review faster because regressions surface in CI instead of on-chain incidents.7kinstalls100Nx Workspace Patternsnx-workspace-patterns is a template-oriented agent skill for solo and indie teams standardizing Nx monorepos. It supplies concrete nx.json layouts: npmScope, affected defaultBase, tasks-runner cacheable operations, parallel limits, and targetDefaults that wire build, test, lint, and e2e to shared input sets. Named inputs separate production sources from specs and config noise so remote cache hits stay high. Generator blocks (for example @nx/react application style) keep new projects aligned with your stack choices. Use it when you are starting or refactoring a polyglot or multi-app repo and want the agent to emit configuration that matches Nx best practices instead of inventing one-off project.json files. It pairs well with CI that runs nx affected and with agents that add libraries without breaking the task graph.7kinstalls101Ml Pipeline Workflowml-pipeline-workflow guides solo builders and small teams who need production-grade machine learning operations without hiring a dedicated MLOps squad. The skill documents how to architect end-to-end pipelines: validate and version data, engineer features with lineage, orchestrate training with experiment tracking, gate releases with validation, deploy models, and feed monitoring back into the loop. It explicitly calls out DAG tools such as Airflow, Dagster, and Kubeflow, plus retry strategies and dependency graphs between components. Use it when you are wiring a new training path, automating retrains, or embedding ML steps into an existing product backend. Advanced complexity—expect comfort with Python ML stacks, containers, and cloud job runners. It complements validate-phase scoping when you are proving a model path, and operate-phase monitoring when pipelines are already live.7kinstalls102Angular Migrationangular-migration is an agent skill that gives solo builders additional patterns and templates for moving AngularJS applications to Angular, with emphasis on forms migration from ng-model forms to template-driven or reactive FormGroup setups. It includes copy-paste before/after HTML and TypeScript snippets, validator wiring, and a multi-week migration timeline starting with Angular CLI, hybrid app configuration, build tools, and testing. Indie teams maintaining brownfield SPAs use it during Build when they must reduce legacy dependency risk without a big-bang rewrite. The readme positions reactive forms as preferred over template-driven where type safety and validation clarity matter. It does not replace a full strangler-fig strategy document but accelerates agent-assisted refactors of high-touch UI surfaces like user forms.7kinstalls103Workflow Patternsworkflow-patterns is a procedural skill for solo builders and agents who already have a plan.md and need repeatable execution discipline. It walks through eleven concrete steps per task: pick the next pending item in the current phase, flip it to in-progress in the plan, write failing tests that encode behavior, implement the smallest code that passes, then refactor while keeping tests green. The readme emphasizes separate commits for status changes versus implementation, ordered phases without skipping ahead, and explicit coverage for happy paths, edges, and errors. It pairs naturally with planning and subagent-driven development workflows when you want test-first delivery instead of ad-hoc coding. Intermediate complexity—you need a repo, a test runner, and comfort with TDD. It does not replace brainstorming or writing the plan itself; it operationalizes the plan once tasks exist.7kinstalls104Hybrid Search ImplementationHybrid Search Implementation is a compact agent skill for solo builders shipping RAG, internal knowledge search, or marketplace discovery where neither pure vector nor pure keyword search is enough. It ships copy-paste Python for Reciprocal Rank Fusion—merging several ordered result lists without fragile score normalization—and for linear interpolation between embedding similarity and BM25-style keyword hits. The RRF block documents the standard 1/(k+rank) fusion with optional weights so you can overweight semantic recall or lexical precision per use case. That matters when users type exact SKUs or error codes while your embeddings favor paraphrases. The skill is template-first: you wire your own indexes, then drop these functions into a FastAPI route, Lambda handler, or batch re-ranker. Intermediate complexity assumes you already produce ranked lists from two retrievers. It does not replace index design or chunking strategy; it solves the ranking merge step that often breaks hybrid demos in production.7kinstalls105Shellcheck Configurationshellcheck-configuration is an agent skill that teaches solo and indie builders how to install ShellCheck and tune it for real repositories. ShellCheck performs static analysis on shell scripts and surfaces on the order of 100 distinct warnings and errors, which makes consistent configuration essential once scripts power deploy hooks, release automation, or local dev tooling. The skill walks through project-root `.shellcheckrc`, optional enable rules such as avoid-nullary-conditions and require-variable-braces, targeted disables when sourcing or word-splitting rules are noisy, and environment overrides like SHELLCHECK_SHELL and SHELLCHECK_STRICT. It also covers editor and CI/CD integration patterns implied by the toolchain focus, plus worked parser-error examples so agents can explain SC1004 continuation mistakes and invalid test operators. Use it when you are standardizing lint rules across contributors or onboarding an agent to fix script review comments systematically rather than debating each warning ad hoc.7kinstalls106Incident Runbook Templatesincident-runbook-templates equips solo builders and tiny platform teams with opinionated, copy-ready runbook structure for service outages and similar production failures. The skill documents detailed patterns—starting with a Payment Processing Service example—that weave together impact assessment, alert and dashboard links, and a disciplined first-five-minute triage script including shell and curl checks against health endpoints, databases, and third parties. It is meant to be invoked when you are drafting or refining on-call documentation, not when you are still guessing what your service does. Agents can extend the templates to your stack while preserving sections for detection, classification, and escalation. Pair it with your real observability URLs and command aliases. Advanced users get the most value when Kubernetes or similar orchestration is in play; beginners can still strip the bash blocks and keep the checklist semantics for a simpler deploy target.7kinstalls107Similarity Search PatternsSimilarity Search Patterns is an agent skill packaging worked templates—starting with a PineconeVectorStore class—for implementing vector upsert and similarity query flows in Python backends. Solo builders shipping RAG chat, recommendation stubs, or agent memory layers use it when they need concrete batching, namespace, and filter patterns instead of re-deriving API shapes from docs. The readme centers on Pinecone serverless indexes on AWS us-east-1, cosine distance, and batched upserts of one hundred vectors per call, with search parameters for top_k and optional metadata filters. It is a build-phase integration aid: you still bring embeddings, auth, and index design. Pair it with embedding pipeline skills and ship-phase testing before production traffic. No automated benchmarks or install metrics are claimed in the skill text.7kinstalls108Multi Cloud ArchitectureMulti-Cloud Architecture is a reference skill for solo founders and small teams who must choose where workloads live without locking into a single vendor slide deck. It documents four strategic patterns—active-active regional splits, best-of-breed service mixing, primary/disaster-recovery pairing, and a portable platform baseline—and explains when asynchronous replication and traffic steering matter. Comparison tables map common compute and storage needs to AWS, Azure, GCP, and OCI equivalents so agents can draft decision records instead of generic “use Kubernetes” advice. The content stresses operational reality: validate RPO/RTO with failover drills, document IAM and networking exceptions, and standardize golden paths behind modules. Use during validation when scoping infra, during build when aligning integrations, and during operate when revisiting DR. It is advisory architecture knowledge, not a deploy generator; pair it with your IaC repo and observability stack.6.9kinstalls109Vector Index Tuningvector-index-tuning is an advanced agent skill for solo builders shipping semantic search or RAG backends. It supplies Python templates to sweep HNSW parameters—M, ef_construction, and ef_search—using hnswlib on cosine space, while timing index builds and queries and estimating graph memory. You bring labeled ground truth for recall@k comparisons so you do not ship default index settings that look fast in dev but miss relevant chunks in prod. The skill is phase-specific to Build → backend: it does not replace observability in Operate, but it prevents the classic mistake of copying tutorial ef values into a dataset ten times larger than the demo.6.9kinstalls110Distributed Tracingdistributed-tracing teaches solo builders how to reason about request journeys across microservices and wire a Jaeger-backed pipeline on Kubernetes or Docker Compose. You learn the mental model—traces as end-to-end IDs, spans as timed operations, context and tags for search—then follow concrete deployment steps such as installing the Jaeger Operator, declaring a production Jaeger CR with Elasticsearch storage, or running the all-in-one container with documented host ports for UI and collectors. Indie founders shipping a small API mesh or agent orchestration layer use it when p95 latency spikes and logs alone cannot show which downstream call stalled. It bridges Build when you add instrumentation libraries and Operate when you keep the observability namespace healthy. The skill is pattern-heavy reference material suitable for agents generating manifests, runbooks, or onboarding docs without replacing your APM vendor choice.6.9kinstalls111Screen Reader TestingScreen Reader Testing is an agent skill for solo builders shipping web apps or hybrid mobile experiences who must prove real assistive-technology usability—not just passing axe or Lighthouse. It teaches how to plan coverage across VoiceOver on Apple platforms, NVDA and JAWS on Windows, TalkBack on Android, and Narrator on Edge, including which browser pairings matter for indie teams with limited hours. The guide connects testing goals to concrete scenarios: validating ARIA roles and labels, debugging broken announcements on SPA updates, checking forms and error associations, and exercising keyboard-first navigation paths. Use it during ship testing before marketing an accessible product, or mid-build when implementing complex widgets. Catching NVDA versus VoiceOver divergences early prevents expensive rework and reduces support burden after launch when disabled users cannot complete core tasks.6.9kinstalls112Saga OrchestrationSaga orchestration is an agent skill for solo builders and small teams shipping distributed systems without two-phase commit. You supply service ownership, which steps must behave atomically vs eventual, retry policies, and your existing event bus; the skill returns a concrete saga definition, coordinator implementation, compensations, deadlines, and observability hooks. It applies when order flows span inventory, payment, and fulfillment, when travel or booking workflows must roll back partially booked resources, or when production investigations show sagas frozen mid-compensation. The workflow emphasizes explicit failure semantics and always-succeeds rollback steps so partial failures do not leave inconsistent business state. Complexity is intermediate to advanced because it assumes multiple services and messaging infrastructure already exist.6.9kinstalls113Hybrid Cloud NetworkingHybrid Cloud Networking guides solo builders and small teams who must connect on-premises systems to public cloud without treating the internet as the only path. The skill frames when to use site-to-site VPN versus provider dedicated connectivity, maps each hyperscaler’s private link product, and gives design rules that matter at indie scale only when you already run hybrid or regulated data. It emphasizes hub-and-spoke termination into transit gateways or equivalent hub layers, redundant physical paths, and keeping VPN as failover. You get a concise comparison table and actionable checklist—BGP advertisement checks, failover drills, MTU assumptions—so agents do not hand-wave “just use VPN.” Use it while planning a migration, hardening production links, or answering architecture questions before committing to a single cloud’s connectivity SKU.6.9kinstalls114Spark Optimizationspark-optimization is procedural knowledge for Apache Spark and PySpark performance. It walks solo builders and small teams through partitioning math, shuffle-aware repartition and coalesce choices, join hints such as broadcast for small dimension tables, and write layouts that enable partition pruning on object storage. The skill fits when you already have a Spark job that is slow, memory-heavy, or expensive to run, and you need concrete patterns rather than generic tuning advice. It assumes familiarity with DataFrames and distributed execution, and focuses on decisions that matter on real clusters: skew, shuffle volume, and scan size. Use it during backend pipeline implementation or when refactoring an existing job before ship-phase load tests.6.9kinstalls115Anti Reversing Techniquesanti-reversing-techniques is an advanced agent skill reference for solo builders and security-minded developers who work with packed or protected Windows PE binaries—not typical CRUD SaaS stacks. It documents packer families, static versus dynamic unpacking workflows, original entry point (OEP) hunting, and import-table recovery patterns extracted into a dedicated reference so the main skill stays approachable. Invoke it when you are analyzing suspicious executables, researching how protectors obscure code, or hardening your own native tooling against trivial unpacking. The material assumes comfort with debuggers, memory dumps, and toolchain names like Scylla and ImpREC. It is intentionally niche compared to web application security skills; most indie web products will never need it unless you ship desktop agents, games, or security tooling.6.9kinstalls116Postmortem WritingPostmortem Writing is an agent skill for solo builders and tiny teams who need consistent, blameless incident documentation without reinventing structure after every outage. It provides a Standard Postmortem template with metadata (date, authors, severity, duration), an executive summary pattern, quantified impact bullets, and a UTC timeline table that mirrors how on-call engineers actually narrate events from alert to rollback. The included worked example (payment service outage, connection pool exhaustion, rollback) shows how to link deployment changes to customer-visible failure and support load. Use it after ship-phase incidents land in production and during operate-phase iteration when you turn ad-hoc Slack threads into a durable record for prevent-recurrence actions. The skill is template-driven rather than an integration; agents paste logs and decisions into each section. Beginners benefit from the scaffolding; advanced teams still gain speed from uniform severity and status fields. Outputs are review-ready markdown suitable for internal wikis or customer trust pages when redacted.6.9kinstalls117Projection PatternsProjection Patterns is an agent skill that gives solo builders copy-paste templates for event-sourcing read models: define projections that declare handled event types, apply mutations idempotently, and run them through a Projector that batches reads from the store and persists checkpoints. It fits builders shipping SaaS APIs who want CQRS-style query sides without ad-hoc cron scripts. The skill emphasizes registration, continuous run loops, and separation between event_store and checkpoint_store—decisions you make during backend build and revisit when operating at scale. Use it after you have a stream taxonomy; the agent helps scaffold Python async structure rather than choosing your database vendor. Pair with your own monitoring in Operate once projections lag or replay times spike.6.9kinstalls118Sast ConfigurationSAST Configuration is an agent skill for solo builders and small teams implementing DevSecOps: it explains how to configure Static Application Security Testing with Semgrep, SonarQube, and CodeQL so vulnerabilities surface in pull requests instead of production. Coverage spans custom rule authoring across common languages, wiring scans into CI/CD, setting quality gates and compliance policies, and reducing noise from false positives while keeping scan times acceptable. It also describes layering tools for defense-in-depth and enterprise SonarQube integration when you outgrow a single scanner. Use it when you are shipping a SaaS or API codebase and need repeatable, automated SAST rather than one-off manual reviews.6.8kinstalls119Binary Analysis PatternsBinary analysis patterns is an agent skill that catalogs low-level reverse-engineering reference material: x86-64 stack frames, calling conventions on Linux/macOS versus Windows, and related disassembly idioms builders encounter when inspecting ELF, PE, or firmware-adjacent artifacts. Solo developers shipping native extensions, CLI tools with C/Rust dependencies, or agents that must reason about compiled binaries can use it to decode what disassemblers show without re-deriving ABI rules each time. It supports Ship-phase security reviews, validate-stage spike analysis on suspicious binaries, and Operate-phase post-incident study when you need to understand injected or tampered machine code. The skill is pattern documentation, not a substitute for licensed disassemblers or formal malware labs. Expect advanced reading comfort with assembly and pointers.6.8kinstalls120Python Resiliencepython-resilience is an agent skill that teaches solo builders how to harden Python code against transient failures using battle-tested patterns from extended worked examples. It covers logging retry attempts with structlog and tenacity’s before_sleep callback, defining stop and wait strategies, and wrapping async functions with consistent timeout decorators. The material assumes you are shipping services, scripts, or agent backends that call external HTTP APIs, queues, or databases where timeouts and retries are non-negotiable. Use it when scaffolding integration clients, refactoring brittle try/except loops, or standardizing how your repo reports backoff behavior for debugging and alerts. It complements configuration and observability skills by focusing on the failure path rather than happy-path business logic. Intermediate Python async familiarity helps; outputs are copy-paste-ready patterns you adapt to your call sites rather than a turnkey framework install.6.8kinstalls121Paypal Integrationpaypal-integration is an agent skill for solo builders and small teams implementing PayPal in a web app or API backend. It documents Express Checkout-style server flows: obtain credentials, choose sandbox or live base URLs, fetch bearer tokens, and create capture-intent orders with structured purchase unit amounts. The worked Python PayPalClient class shows how to encapsulate authentication and POST to PayPal’s REST endpoints so your agent does not hallucinate endpoint paths or payload shapes. Use it while building checkout, billing, or marketplace payouts—not for marketing pages or fraud analytics alone. Pair it with your existing secrets management and webhook handlers; the skill focuses on order creation patterns rather than full subscription lifecycle or dispute tooling. Expect intermediate familiarity with REST APIs and environment-specific keys.6.8kinstalls122Python Background JobsPython Background Jobs is an agent skill built around concrete Celery and FastAPI examples for asynchronous work. Solo builders shipping APIs often underestimate webhook retries, stuck tasks, and clients that need job status—this skill encodes advanced patterns like dead-letter queues after exhausted retries, exponential backoff, and HTTP endpoints that expose job state. It assumes you are past the prototype stage and need durable queue semantics rather than a one-off script. The content is example-driven (bind tasks, DLQ payloads with timestamps, GET /jobs/{job_id}), so it pairs well with an existing Python service repo. Use it during backend implementation and again when you operate queues and debug poison messages. Complexity is intermediate because you need Celery workers, brokers, and deployment discipline—not just copy-paste snippets without infrastructure.6.8kinstalls123Turborepo CachingTurborepo Caching is an agent skill for solo and indie builders who run JavaScript/TypeScript monorepos and need predictable, fast builds in local dev and CI. It walks through when to adopt Turborepo—new monorepos, pipeline design, remote cache, CI speedups, migrations, and diagnosing misses—and explains core pipeline concepts such as dependsOn, outputs, inputs, caching flags, and persistent tasks. The skill includes a structured turbo.json configuration template and architecture diagrams so your agent can align task graphs with package boundaries instead of guessing. For Prism’s journey, it sits in Ship because the payoff is safer, quicker releases after the codebase is real; it is not a product-validation or growth play. Use it when pnpm/npm workspaces are in place and build time or CI cost is the bottleneck.6.8kinstalls124Employment Contract TemplatesEmployment Contract Templates is a document skill from the wshobson agents collection that gives solo and indie builders reusable markdown patterns for core hiring paperwork, starting with a full employment offer letter skeleton. Instead of drafting legal-ish prose from scratch in chat, you point your coding agent at consistent headings—role details, pay, benefits, contingencies—and swap bracket placeholders for your company facts. It fits founders who are shipping a SaaS or agency and suddenly need a credible offer without a full HR stack. The skill does not replace a licensed attorney for jurisdiction-specific terms, but it compresses time-to-first-offer and keeps language aligned across candidates. Use it when you are operating the business side of the build: first contractor or employee, advisor equity mentions, or refreshing standard onboarding packets. Pair with your own counsel review before anything is signed.6.8kinstalls125Defi Protocol Templatesdefi-protocol-templates is an agent skill that supplies Solidity reference implementations for common DeFi building blocks, starting with governance tokens and governor contracts. Solo builders experimenting with on-chain products can paste OpenZeppelin-based patterns—ERC20Votes, permits, ownership, and proposal lifecycle fields—then adapt naming, supply, thresholds, and voting periods to their network. The skill emphasizes pragma 0.8.x and license headers so generated code fits standard Hardhat or Foundry workflows. It is aimed at indie hackers and small teams who want an LLM to extend or combine modules rather than invent governance mechanics cold. Use it during Build when the product shape is already validated and you need contract skeletons before formal audit or testnet deploy. It does not replace security review, economic design, or deployment runbooks—it accelerates the first correct-looking contract draft your agent can refine.6.8kinstalls126Pci Compliancepci-compliance is an agent skill that supplies copy-paste Python patterns for PCI-aligned access control and audit logging when you expose payment-method or cardholder-data endpoints. Solo and indie builders shipping checkout, billing, or wallet features in Flask-like stacks can use it to gate routes behind explicit roles, record every access attempt, and centralize audit entries instead of improvising security in chat. The skill does not replace a QSA or full PCI program—it accelerates consistent guardrails during implementation and pre-launch reviews. Invoke it while designing payment APIs, hardening admin tools that touch PAN-adjacent data, or preparing evidence-friendly logging before Ship and Operate monitoring work.6.8kinstalls127Python Resource Managementpython-resource-management is a procedural agent skill for solo builders writing Python backends, CLIs, and integration code who need deterministic teardown of scarce resources. It centers on the `with` statement and the context-manager protocol so database connections, file handles, and network sockets are released on both happy paths and failures. The skill walks through `@contextmanager`, custom class-based managers, async context managers, and patterns for streaming responses that must flush or close state reliably. Use it when implementing connection pools, layered I/O, or any code where leaking handles would destabilize production. It pairs well with API and SaaS shapes where long-lived processes and pooled resources are common. Complexity sits at intermediate: you should already write normal Python functions and exceptions before adopting custom managers.6.7kinstalls128Team Composition AnalysisTeam Composition Analysis is a planning skill for founders and solo builders who are outgrowing pure founder-mode execution and need a credible hiring roadmap tied to funding stage. It breaks down typical org shapes from pre-seed through Series A across engineering, sales and marketing, product, and customer success, including indicative compensation ranges that help you sanity-check burn against Validate scope and Grow ambitions. Pre-seed guidance keeps founders on code and sales with light contract help; seed introduces first engineering and revenue leaders; Series A expands management layers, specialists, and CS coverage. The skill does not replace HR legal setup or recruiting pipelines—it gives agents a structured template for headcount conversations, board slides, and runway models. Use it when you are validating whether your roadmap matches two engineers or ten, or when preparing to hire your first salesperson without copying Big Tech ladders. Prism tags it multi-phase because the same framework informs early scope tradeoffs and later operating scale.6.7kinstalls129Bats Testing Patternsbats-testing-patterns is an agent skill from wshobson/agents that teaches how to test shell scripts with Bats: installation options, TAP-compliant assertions, fixtures, teardown, parallel runs, and dialect coverage for bash, sh, and dash. Indie builders shipping CLI tools, install scripts, or CI glue install it when ad-hoc manual testing is not sustainable. The SKILL.md frames clear triggers—writing unit tests, TDD for scripts, CI/CD automation, and complex fixtures—so the agent proposes file layout and test cases instead of one-off echo checks. It spans multi-phase use: in build while authoring backend or integrations shell helpers, in ship when hardening release scripts, and in operate when regression-testing infra automation. It complements language-specific test frameworks rather than replacing them for non-shell code.6.7kinstalls130Service Mesh ObservabilityService Mesh Observability is a procedural skill for solo builders and small teams running microservices behind Istio or Linkerd who need more than a single APM chart. It walks through the observability stack you actually need in a mesh: request-rate and error metrics, span context across hops, access logs for audits, and how those pieces combine when latency spikes or errors cluster between services. You use it when first wiring mesh telemetry, when intermittent 5xx or tail latency only shows up east-west, or when you must define SLOs that reflect real client paths through gateways and sidecars. The skill frames golden signals for mesh traffic, dependency maps, and practical troubleshooting rather than vendor slideware. It assumes you already deploy services to Kubernetes with a mesh enabled and want dashboards and alerts that match how packets move between pods, not just how one container behaves.6.7kinstalls131Track ManagementTrack management is a journey-wide agent skill for defining logical work units—each with a unique ID, specification, phased plan, and status metadata—so solo builders and small teams can bound scope, track progress, and coordinate git operations around coherent slices of work. It standardizes track types (feature, bug, chore, refactor) and IDs like user-auth_20250115, making agent sessions and human review align on what “done” means. Use it when spinning up a new capability, fixing a defect, or refactoring without behavior change, especially if you want revert-by-track semantics instead of hunting commits. The skill fits indie builders juggling Claude Code or Cursor across Validate scoping and Operate iteration alike, as long as work deserves a named track rather than ad-hoc chat threads.6.7kinstalls132On Call Handoff PatternsOn-call handoff patterns is an agent skill that gives solo builders and small platform teams reusable markdown templates and examples for passing operational context between shifts. Instead of ad-hoc Slack threads, you document active incidents, in-flight investigations, and proactive monitors with impact, history, concrete next steps, and resource links. It fits whenever you run a rotating on-call for APIs, auth, databases, or background jobs and need the next person to resume work without re-triage. The skill emphasizes clarity for low-frequency events (intermittent timeouts, slow memory growth) so investigations do not stall across rotations. Use it at the end of every shift or before PTO to reduce duplicate debugging and missed follow-ups. It is editorial guidance and document structure, not an integration that pages you or mutates production.6.7kinstalls133Slo ImplementationThe slo-implementation skill guides solo builders and small teams through Service Level Indicators and Service Level Objectives end to end: choosing user-facing SLIs, setting achievable targets, wiring burn-rate alerts with combined short and long windows, and running consistent error-budget reviews. It includes YAML examples for high-severity burn-rate combinations, structured weekly through quarterly review agendas, and a ten-point best-practice list covering documentation, automation, and alignment with business goals. Use it when you are moving from ad-hoc uptime checks to an explicit reliability contract that drives on-call noise reduction and roadmap tradeoffs. It assumes you will collect metrics and visualize SLOs with companion skills rather than replacing your observability stack.6.7kinstalls134Bazel Build OptimizationBazel Build Optimization is an agent skill for solo and indie builders running—or migrating to—Bazel in large monorepos. It frames the core mental model: targets, packages, labels, rules, and aspects, plus a conventional workspace layout with apps, libs, and tools. Use it when you are setting up Bazel, wiring remote caching or remote execution, chasing slow builds, authoring custom rules, debugging flaky graphs, or planning a migration from legacy build systems. The skill points to a full template library in references/details.md when you need copy-paste BUILD files and end-to-end examples. It fits teams shipping many services from one repo who need deterministic, cacheable builds at CI scale, not one-off scripts. Expect advanced toolchain concepts; pair it with your org’s CI and cloud credentials before enabling remote execution.6.6kinstalls135Istio Traffic ManagementIstio Traffic Management is an agent skill for solo builders running microservices on Kubernetes with Istio. It explains how to route traffic with VirtualServices, apply post-routing policies in DestinationRules, expose workloads via Gateways, and register external hosts with ServiceEntries. You reach for it when implementing progressive delivery (canary or blue-green), tuning load balancing, adding retries and circuit breakers, mirroring traffic for validation, or injecting faults for chaos experiments. The skill is YAML-template driven and assumes you already operate a mesh—not greenfield app coding. Complexity is advanced because mistakes affect live request paths and blast radius across namespaces.6.6kinstalls136Nft StandardsNFT Standards is a Web3 agent skill that supplements core guidance with additional Solidity patterns for non-transferable soulbound tokens and dynamic ERC-721 collectibles. Solo builders shipping credentials, memberships, or game-linked assets can start from contracts that restrict transfers while allowing user-initiated burns, or from stateful NFTs that accumulate experience and levels on-chain before resolving metadata URIs. The snippets emphasize safe overrides around mint and transfer hooks and owner-only state mutations—typical needs for indie games, creator passes, and progressive badges. It fits the integration step of a dApp roadmap after you have chosen a chain and wallet flow but before audit and mainnet deploy. Pair it with your own access control, gas optimization, and metadata hosting strategy rather than treating the templates as production-audited deployments.6.6kinstalls137Mtls Configurationmtls-configuration is an agent skill that supplies worked Istio YAML for mutual TLS: PeerAuthentication at mesh, namespace, and workload granularity, plus DestinationRules that wire ISTIO_MUTUAL inside the mesh and SIMPLE or full mutual TLS to external and partner APIs. Solo and indie builders shipping Kubernetes services use it when they need a concrete starting point instead of guessing Istio security API shapes during a STRICT rollout or a legacy namespace migration. The readme centers on strict mode by default, permissive escape hatches for brownfield namespaces, and explicit port-level exceptions so observability paths stay usable. It is a template-oriented skill—not a live cluster operator—so you still validate CA trust, sidecar injection, and partner certificate paths in your own environment. Pair it with your mesh install and certificate rotation practices before enabling STRICT fleet-wide.6.6kinstalls138Linkerd Patternslinkerd-patterns teaches production Linkerd setups for Kubernetes—the lightweight, security-first mesh favored when Istio feels too heavy. The skill covers when to adopt Linkerd (mTLS by default, canaries, per-route observability), core architecture with control plane components and injected data-plane proxies beside each app, and implementation flows for traffic policies, splits, service profiles, retries, timeouts, and multi-cluster topologies. Solo builders running a small fleet of microservices on EKS, GKE, or k3s can use it to get mutual TLS and golden metrics without a platform team. Invoke it during Ship launch prep when hardening cluster networking, or in Operate when debugging east-west latency or rolling out a canary. It assumes you already containerize services and manage Helm or CLI installs; outputs are manifest-ready patterns and policy shapes your agent can adapt to your namespace layout.6.6kinstalls139Parallel DebuggingParallel Debugging is a reference-style agent skill that gives you reusable templates for splitting a nasty bug into parallel hypothesis investigations. Instead of letting one agent wander the codebase, you define falsifiable statements, scope files/tests/git history, and require confirming versus contradicting evidence with file-and-line citations. Solo builders shipping fast often stall on intermittent API or state bugs—this skill forces disciplined verdicts and confidence levels so you can merge competing investigations into one fix path. It complements test-heavy Ship workflows by documenting how each hypothesis was tried and why it was rejected. The content is procedural knowledge: markdown schemas for investigation tasks and final reports, not a single automated command. Use it when symptoms are clear but cause is disputed, when you want multiple sub-agents or passes to explore branches without losing audit trail, or when you need a causal chain narrative before touching production config.6.1kinstalls140Parallel Feature Developmentparallel-feature-development gives solo builders a concrete file-ownership framework when one feature touches many modules and you want several coding agents or contributors to work at once without merge conflicts. The process starts by listing every file to create or change, clustering by directory, functional coupling, and layer, then assigning each cluster to a single owner with zero overlap. It documents where clusters meet—shared types, API signatures, and event payloads—and provides ready-made ownership layouts for React/Next.js trees and Express/Fastify service layers plus a designated shared types file owned by a lead. Use it before kicking off parallel implementation on a medium or large feature when ad-hoc splitting has already caused duplicated edits or broken imports.6.1kinstalls141Task Coordination StrategiesTask coordination strategies is a journey-wide agent skill that helps solo builders design task dependency graphs before agents execute parallel work. It walks through four visual patterns—from fully independent tasks with a final integration gate, through sequential chains, diamond shapes where one foundation fans out, to fork-join phases where parallelism happens only within each wave. Each pattern includes when to use it, risks like late integration surprises or cascade delays, and how to express relationships via TaskCreate and blockedBy. Use it whenever you are splitting a feature across files or modules and want maximum parallelism without hidden ordering bugs. It pairs naturally with planning skills that produce a spec list but not the execution graph. Complexity is beginner to intermediate; the value is picking the right shape early instead of rewiring dependencies mid-run.6kinstalls142Multi Reviewer Patternsmulti-reviewer-patterns documents how to split code review across focused dimensions so multiple agent reviewers—or one agent in passes—do not duplicate noise or miss entire risk classes. The published SKILL.md centers on detailed checklists: Security covers injection, XSS, auth, secrets, and dependency risk; Performance covers database access patterns, resource use, and scalable list endpoints. Solo builders use it at PR time to force systematic coverage instead of a single “looks fine” summary, and small teams can map each dimension to a person or a sequential agent invocation. It complements generic review skills by supplying repeatable criteria reviewers must follow during parallel review. You still need your repo’s test suite and CI; this skill does not execute scanners—it structures human and agent judgment. Intermediate complexity assumes you can recognize N+1 queries, JWT pitfalls, and production debug exposure called out in the lists.5.9kinstalls143Team Communication Protocolsteam-communication-protocols gives solo builders who run several agents—or one agent playing multiple roles—copy-ready message shapes so work stays legible. Each template encodes the same fields a human tech lead would demand: task id, subject, owned files, requirements, who exports which types, and what to do when blocked. Integration notifications make explicit when a boundary is stable enough for the next agent to import. Completion and review summaries force delta lists and severity buckets instead of vague “done” replies. Investigation headers tie hypotheses to structured follow-ups. The skill is process knowledge, not an MCP or ticket integration; you paste or adapt templates into your agent orchestration, Slack, or PR comments. It pays off whenever parallelism increases—feature splits, refactors, or audit dimensions—because miscommunication costs more than typing a structured update.5.9kinstalls144Team Composition PatternsTeam Composition Patterns is a journey-wide agent skill that gives solo builders a decision matrix for choosing subagent_type when spawning teammates. It separates Agent Teams specialized roles—team-lead, team-implementer, team-reviewer, and team-debugger—from generic profiles such as general-purpose, Explore, and Plan, and states what each may read, write, edit, or run in bash. The guide answers a common failure mode: parallel agents that duplicate work, mutate the wrong files, or lack coordination hooks. Use it whenever you orchestrate multiple agents on one repo, not only during initial scaffolding. It pairs naturally with team-lead workflows and code-review subagents because the matrix clarifies who should hold team tools versus who should stay read-only. The skill is intermediate complexity: you need basic familiarity with subagent spawning, but no custom framework code.5.9kinstalls145Evaluation MethodologyEvaluation Methodology is reference material for how the eval-judge agent scores skills on four dimensions using fixed anchored rubrics. Solo builders and skill authors use it when they need a shared scoring standard instead of subjective thumbs-up reviews. The document explains what Triggering Accuracy measures—whether frontmatter descriptions cause the agent to invoke a skill at the right times—and how judges mentally simulate prompt sets to estimate precision and recall. It also documents weighting and layer blending for deeper evaluations. Read it before filing disputes, training judges, or tightening a skill description so routing improves. It does not install tools or run evaluations by itself; it defines the rules eval-judge follows when reading SKILL.md and references. Pair it with hands-on skill authoring workflows when you are iterating descriptions, triggers, and reference files for catalog or private repos.3.4kinstalls146Hadshads teaches agents the Human-AI Document Standard (HADS 1.0.0), a Markdown convention for technical documentation that stays readable for people while giving models explicit reading instructions. Solo builders and small teams use it when internal specs, API notes, or runbooks must survive repeated agent sessions without ballooning token use. The skill defines four block types—SPEC for facts, NOTE for human context, BUG for verified failures with fixes, and ? for inferred content—and requires an AI manifest that tells the model what to read or skip. It supports generating new HADS documents, converting existing docs, and validation passes. Placement is primarily Build/docs, but the same files support review during Ship and operations during Operate when agents need reliable procedural knowledge.2.9kinstalls147Block No Verify HookBlock No-Verify Hook is an agent skill for solo builders who enforce git hygiene while using Claude Code. AI agents often run git commit or push with --no-verify to avoid hook failures, which lets unformatted code, lint errors, skipped tests, and unsigned commits into the repo. The skill documents adding a PreToolUse guard that rejects Bash commands containing bypass flags before they execute. It fits Ship review workflows and any Build session where the agent commits on your behalf. Setup is configuration in project settings rather than a standalone CLI—ideal when you already rely on pre-commit, husky, or custom hooks and want agent behavior to match human contributors.2.9kinstalls148Protect Mcp SetupProtect MCP Setup configures cryptographic governance for Claude Code: Cedar authorization runs before powerful tools execute, and every decision becomes an Ed25519-signed receipt you can verify offline. Solo builders and small teams adopt it when AI agents can move money, change production, or touch sensitive data—and a normal chat log is not enough because it can be edited, is unsigned, and forces you to trust whoever holds the file. The skill walks through policy enforcement plus signed receipts so compliance-minded projects get policy-gated execution and evidence chains instead of hope-based auditing. It pairs naturally with MCP-heavy agent workflows where Bash, Edit, Write, and WebFetch need guardrails. Implementation expectations include Cedar as the policy engine, receipt hashing for integrity, and Veritas Acta-style verification without a central account. Use during security hardening before wide agent rollout, and keep policies versioned with your repo so receipts remain explainable months later.2.3kinstalls149Signed Audit Trails Recipesigned-audit-trails-recipe is a step-by-step security cookbook for solo builders and small teams who need provable agent behavior in regulated or high-trust settings. It explains how every Claude Code tool invocation can be denied upfront by Cedar policy and recorded afterward as an Ed25519-signed receipt chain that third parties verify offline. You reach for it when evaluating finance, healthcare, or CI pipelines where “the agent probably behaved” is not enough evidence. The skill deliberately teaches the pattern before you install protect-mcp hooks, covering tamper detection, auditor workflows, and composition with supply-chain attestations. It is dense policy-and-crypto material—not a one-click installer—so pairing with Ship security review and Operate monitoring practices is natural.2.1kinstalls150Review Agent SetupReview Agent Setup configures review-agent-governance for Claude Code projects where an agent might post PR reviews, merge, comment on issues, publish releases, edit GitHub or GitLab CI, push to protected branches, or hit Slack and Discord webhooks. Solo builders increasingly let agents drive gh CLI operations; without gates, one mistaken merge or workflow edit is costly. This skill walks one-time plugin install, copying the default Cedar policy into the repo, and tailoring rules so attempts require human approval while producing a cryptographically auditable trail. It is intentionally narrow: if the agent never touches GitHub write surfaces, the README says the plugin is overkill and points to protect-mcp for general tool policy. Treat it as intermediate setup—you need comfort with Cedar concepts, branch protection, and CI layout. Primary shelf is Ship/security, but it also belongs wherever you configure agent tooling before enabling autonomous review flows.1.5kinstalls151ScanScan is an agent skill that treats your repository like a product to document: it walks the codebase and emits project-doc.md plus AGENTS.md so downstream coding agents inherit accurate, project-specific guidance instead of generic assumptions. Solo and indie builders reach for it when spinning up a new agent-driven repo, after meaningful refactors, or whenever AGENTS.md has fallen behind the real architecture. The first invocation runs a comprehensive pass; later invocations prefer a delta-oriented scan so you are not re-paying the full cost on every session. When Lum1104 Understand-Anything and mksglu context-mode plugins are installed, the skill leans on them for richer semantics and safer context-window handling; without them, the same outcomes are pursued through native shell and git tooling. AGENTS.md is deliberately conservative—architectural updates require explicit human approval so automation does not silently rewrite your team’s source of truth. The result is a living documentation layer that scales with agent workflows from initial build through ongoing iteration.822installs152Recsys Pipeline ArchitectRecsys Pipeline Architect is an agent skill that helps solo builders spec and scaffold composable recommendation, ranking, and feed systems using a six-stage pipeline pattern popularized by xAI’s open For You algorithm. Most production “recsys” is not a single model—it is fetching candidates from sources, hydrating metadata, filtering ineligible items, scoring, selecting top K, and running async side effects. Invoke when you are building personalized feeds, search result ordering, RAG rerankers, notification triage, or any system that must return the best K items for a user and context. The skill encodes repeatable interfaces and stage boundaries so you can swap scorers and item types while keeping the same pipeline skeleton, which matters for indie SaaS, agent tools, and API products that need explainable, testable ranking paths.604installs153Social PublishingSocial Publishing is an agent skill that wraps the SocialClaw API so your coding agent can schedule and publish social content across thirteen networks from one integration surface. It targets solo and indie builders who want programmatic distribution—launch threads, LinkedIn updates, Discord announcements, and blog cross-posts—without building thirteen separate OAuth flows. Use it when the user asks to push or queue content, run a coordinated campaign, attach media, or pull basic engagement stats back into the workspace. The skill assumes SOCIALCLAW_API_KEY is configured and treats SocialClaw as the broker for platform-specific quirks called out in its platform table (threads, company pages, subreddit flair, WordPress SEO fields, and similar). It complements human copywriting skills rather than replacing brand strategy: the agent handles API orchestration and calendar mechanics while you supply messaging. For builders in Launch and Grow, it shortens the path from shipped feature to visible distribution.1installs