jeffallan/claude-skills
66 skills252k installs642k starsGitHub
Install
npx skills add https://github.com/jeffallan/claude-skillsSkills in this repo
1Laravel Specialistlaravel-specialist packages opinionated Eloquent ORM guidance for agents helping solo founders ship Laravel backends faster. It starts with a modern Post model example: guarded mass assignment lists, soft deletes, JSON metadata casts, and Attribute-based accessors that normalize title casing and derive excerpts from long content. Relationship sections show the idiomatic hasMany/hasOne patterns, including latestOfMany and oldestOfMany for pinning a single related row without raw SQL. Builders use it when scaffolding domain models, tightening N+1-prone graphs, or migrating legacy mutator strings to the Attribute API. The skill does not replace Laravel docs for authorization, policies, or testing—it narrows agent output to structurally sound models teams can drop into app/Models. Pair with migration and API resource skills when exposing models over HTTP.14.8kinstalls2Golang Progolang-pro packages senior Go implementation habits for solo builders shipping APIs, CLIs, or small microservices without a staffed platform team. Invoke it when the task needs more than syntax—concurrency design, narrow interfaces, error wrapping with context, module layout, gRPC or REST service boundaries, and the discipline to run go vet and golangci-lint before moving on. The workflow starts by reading existing packages and concurrency risks, then composes small interfaces, implements with explicit error paths, and validates with lint tooling rather than vibe-based merges. It aligns with cloud-native and performance-sensitive backends where table-driven tests and pprof matter. On Prism it is tagged multi-phase because the same patterns support Build feature work, Ship review prep, and Operate hardening, even though the canonical shelf stays backend. Related skill names in metadata point toward devops, microservices architecture, and testing depth when your stack grows past a single binary.13.8kinstalls3Flutter ExpertFlutter Expert (Bloc State Management) is an agent skill that teaches when and how to structure Flutter apps with Bloc and Cubit instead of lighter providers. Indie mobile builders reach for it when a screen needs explicit user/system events, immutable state, and logic that must stay testable outside widgets—typical for authentication, multi-step forms, and feature modules. The readme contrasts Riverpod for simple mutable state against Bloc for event-driven workflows, then walks through sealed events, immutable state objects, `copyWith`, and `flutter_bloc` registration with `on<>` handlers. It is intentionally pattern-oriented: you still bring your domain events and navigation, but the skill keeps new code aligned with predictable Event → State mapping. Use during Build while scaffolding or refactoring Flutter features; skip when you only need ephemeral UI toggles better served by Riverpod or local `setState`.11.6kinstalls4Php ProPHP Pro is an agent skill aimed at intermediate solo builders shipping PHP APIs who need production-oriented async patterns, not just Laravel CRUD defaults. The surfaced content centers on Swoole: configuring an HTTP server with multiple workers, coroutine-friendly request handlers, JSON responses, and concurrent outbound calls without blocking the entire process pool. It fits Build-phase backend work when you are choosing runtime architecture—traditional FPM versus Swoole—for latency-sensitive or high-concurrency endpoints. Agents can use it to scaffold strict-typed server files, wire basic REST paths, and structure coroutine runs for parallel I/O. It does not replace framework-specific Laravel skills; it complements them when you explicitly want Swoole-style concurrency and server ownership in plain PHP.10.5kinstalls5Kubernetes SpecialistKubernetes-specialist (configuration management slice) gives solo builders and small teams copy-paste-correct Kubernetes objects for non-secret settings and sensitive credentials. It walks through ConfigMap structures from simple database host keys through multi-line app.properties, JSON feature flags, and embedded YAML fragments, plus kubectl one-liners to bootstrap maps from literals or filesystem trees. On the secrets side, it distinguishes stringData convenience from pre-encoded data blocks and shows Opaque secrets for database passwords, API keys, and TLS assets in a named namespace. Use it while you are hardening a Ship launch checklist, standing up Operate monitoring for a new service, or refactoring Build-time twelve-factor config into cluster-native objects. The skill is reference depth, not a full cluster bootstrap course—pair it with your deployment pipeline and secret store policies.10.2kinstalls6Spring Boot Engineerspring-boot-engineer is a procedural Java skill that steers coding agents through Spring Boot and Spring Cloud production idioms—especially centralized configuration and runtime refresh—so solo builders shipping JVM APIs do not re-learn the same YAML and annotation wiring on every service. It packages concrete Config Server and Config Client examples with security hooks, Git repository layout conventions, and RefreshScope patterns for toggling features after deploy. The audience is indie SaaS founders or small teams standardizing on Spring for BFFs and microservices who want consistent answers when agents scaffold new modules or refactor legacy monoliths. Use it when conversations drift into service discovery adjacency, externalized secrets placeholders, or cloud-native bootstrapping rather than generic Java syntax. It complements framework docs by encoding opinionated, paste-ready structures agents can extend into your repo’s package layout.6.3kinstalls7Devops EngineerDevOps Engineer is a implementation-focused agent skill for solo builders who need production-grade delivery without a platform team. It embodies a senior engineer role across build automation, multi-environment deploy orchestration, and ops reliability. Invoke it when containerizing services, authoring CI/CD, managing cloud IaC, configuring Kubernetes or GitOps, or drafting incident runbooks. The skill emphasizes code-shaped deliverables—Dockerfiles, pipeline YAML, manifests, and templates—rather than vague advice. It spans Ship (launch, security adjacency) and Operate (monitoring, on-call) naturally, so tags treat launch as the primary shelf with infra and iterate as secondary contexts. Pairs well with dedicated Terraform, Kubernetes, SRE, and security-reviewer skills named in metadata for deeper passes after this skill scaffolds the baseline.5.9kinstalls8Wordpress Prowordpress-pro is an agent skill that guides solo builders and small agencies through modern Gutenberg block development on WordPress 6.4 and newer. It treats blocks as the primary composition unit—static HTML saves, server-rendered dynamic blocks, and interactive client-side blocks for accordions, tabs, and carousels. The skill walks through bootstrapping with @wordpress/create-block, choosing interactive or dynamic variants, and the expected folder contract from plugin bootstrap PHP through src/block.json, React editor code, save handlers, and compiled build assets. npm scripts center on @wordpress/scripts for build, watch, format, and lint workflows so agents do not invent bespoke bundlers. Use it when you are shipping a block plugin or extending the editor for a client site, not when you only need classic PHP theme templates without blocks. The readme fragment focuses on project setup and structure; pair it with your theme or headless plan separately if you are not editing in Gutenberg.5.4kinstalls9Architecture DesignerArchitecture Designer is an agent skill that equips solo and indie builders to write Architecture Decision Records using a consistent markdown template. Instead of losing the reasoning behind database picks, service boundaries, or hosting choices in old threads, you produce a short, citable doc that states context, the decision, consequences, and rejected alternatives. The bundled example walks through a realistic PostgreSQL-on-RDS choice for an e-commerce-style workload, which makes it easy to mirror the pattern for auth, queues, or monolith-versus-services calls. Use it whenever a choice is hard to reverse, affects cost or compliance, or will confuse an coding agent six months later. The output is plain markdown you can commit beside code, link from README, or feed into planning skills—no external service required.4.3kinstalls10Websocket EngineerWebsocket Engineer is an agent skill that helps solo builders pick the right real-time stack instead of defaulting to WebSockets everywhere. It compares WebSocket, Server-Sent Events, long polling, HTTP/2 server push, and WebRTC on bidirectional need, browser support, proxy friction, and overhead—so a notification bar might land on SSE while a game room stays on WebSockets or WebRTC. The SKILL.md emphasizes practical server patterns, including Node.js Express handlers that set text/event-stream headers, keep-alive connections, periodic data writes, and cleanup on client close. Use it when you are wiring live dashboards, chat, collaborative editors, or stock-style tickers and need firewall-friendly options or legacy fallbacks. It is reference-oriented integration knowledge for Claude Code and Cursor sessions implementing backend routes, not a full auth or scaling guide.4.2kinstalls11Sql ProSql-pro is a database design and SQL craftsmanship skill aimed at builders who need trustworthy relational models without hiring a DBA on day one. It walks through normalization levels with concrete before-and-after table definitions, emphasizing atomic columns, eliminating partial dependencies, and preserving historical facts such as unit price at order time. Solo founders use it when sketching MVP schemas, refactoring tangled tables, or teaching an agent how to generate migrations that will not paint them into a corner at scale. The material is oriented toward PostgreSQL-flavored DDL but the modeling lessons transfer to MySQL and SQLite backends. Reach for it during backend implementation, when validating data models before launch, and when operating legacy apps that need safer schema changes.4kinstalls12Postgres Propostgres-pro is a procedural PostgreSQL reference skill for solo builders shipping APIs and SaaS backends who need correct extension usage without digging through docs each time. It walks through listing available and installed extensions, safe CREATE EXTENSION IF NOT EXISTS installs, drops, and version updates for staples like pg_stat_statements, uuid-ossp, and pg_trgm. For operations-minded builders, it includes copy-paste diagnostics: top queries by mean time, call count, and total execution share, plus reset of statement statistics. Use it during backend build when you wire auth IDs and search, and again in Operate when you profile regressions. It is reference-style SQL snippets meant to be run against your database connection, not a hosted MCP server. Pair with your migration workflow and connection secrets handled outside the skill.4kinstalls13Embedded Systemsembedded-systems is a specialist agent skill for developers building on microcontrollers when agents otherwise hallucinate desktop patterns. It targets STM32, ESP32, FreeRTOS, bare-metal bring-up, peripheral configuration, interrupt handlers, DMA, and real-time timing debug. The workflow forces constraint analysis first—MCU specs, memory ceilings, deadlines, and power budget—then architecture for tasks and interrupts, HAL and driver implementation, validation with strict warnings and cppcheck-style checks, resource optimization, and hardware verification. Solo builders shipping IoT gadgets, wearables, or industrial edge nodes use it during Build to keep register-level code aligned with datasheets. Output is implementation-focused C/C++ firmware, not product management. Complexity is advanced because mistakes affect safety, timing, and field reliability.3.9kinstalls14Rust Engineerrust-engineer is an agent skill package aimed at solo and indie builders who are implementing Rust backends, CLIs, or agent-side tools where correctness and concurrency matter. The documented material walks through async function design, choosing Tokio as the runtime, and structuring main so futures actually execute—failure modes that burn hours when you treat Rust like synchronous Go or Python. You reach for it during Build when you are wiring network calls, overlapping independent I/O with join or spawn, or hardening error paths with ? across await boundaries. For a one-person shop shipping an API or worker, the skill compresses repeated Stack Overflow loops into procedural knowledge your agent can apply consistently across modules. It is not a substitute for crate selection or architecture review, but it keeps implementation aligned with idiomatic async Rust so you spend less time fighting the compiler and runtime and more time finishing features before ship.3.8kinstalls15Java ArchitectJava Architect is an agent skill aimed at solo and indie builders who ship Spring Boot services and need Hibernate/JPA entities that stay performant in production. It encodes opinionated entity design—indexes on lookup columns, lazy collections with batch fetching, auditing hooks, and cache concurrency choices—so agents do not emit naive @OneToMany graphs that N+1 the database. Use it when you are implementing or refactoring domain models, tightening fetch plans, or aligning Lombok builders with Jakarta Persistence annotations. It matters because persistence mistakes are expensive to unwind after launch: the skill pushes lazy loading, explicit cascades, and index declarations up front. Pair it with your migration tool and repository layer; it does not replace query tuning or infra-level connection pooling.3.7kinstalls16Code ReviewerCode Reviewer is a specialist agent skill that acts like a senior engineer reviewing pull requests and file changes. It starts from PR context, walks security and performance risks, code quality and test gaps, and architecture fit, then delivers a constructive prioritized report. Solo builders using Claude Code or Cursor can invoke it for PR reviews, quality audits, refactoring triage, and security spot-checks without spinning up separate tools for every dimension. It intentionally complements narrower skills such as security-reviewer and test-master rather than replacing them. Allowed tools are read-only exploration (Read, Grep, Glob), so it fits repos you already have open. Use it in Ship before merge; it also helps during Build when validating architectural decisions on in-progress features.3.6kinstalls17Typescript ProTypeScript Pro is an agent skill that packages advanced TypeScript type-system patterns—generic constraints, conditional types, mapped types, and practical utility recipes—as copy-ready guidance for solo builders using Claude Code, Cursor, or Codex. Install it when you are implementing shared libraries, API clients, or strict domain models and need compile-time safety without pausing to reread the handbook. It fits the Build phase most often on frontend and backend surfaces, and it resurfaces during Ship review when tightening types before release. The skill is reference-heavy procedural knowledge, not a checker or external integration, so you bring the files and the agent applies the patterns in context. Expect intermediate-to-advanced material aimed at indies who already write TS daily and want fewer `any` escapes and clearer generic APIs.3.6kinstalls18Api DesignerAPI Designer is an agent skill focused on how your HTTP API should fail in a predictable, documented way. Solo builders shipping REST or JSON APIs for SaaS products, internal tools, or agent-facing backends use it when defining error envelopes before wiring controllers or OpenAPI specs. The skill walks through a simple error wrapper, full RFC 7807 Problem Details responses, and extended validation payloads with multiple field failures, request correlation IDs, and links to human-readable docs. That matters because inconsistent errors force every client and coding agent to guess semantics, while a single format speeds integration tests, SDK generation, and support. Use it during backend build when you are drafting routes, revising breaking changes, or aligning mobile and web clients on the same failure contract. It is reference-oriented design guidance rather than a deploy or security audit tool.3.6kinstalls19Fastapi ExpertFastapi Expert packages async SQLAlchemy setup and ORM model patterns that FastAPI backends rely on when you want typed models, pooled connections, and relationship loading that works with async sessions. Solo builders use it while implementing persistence before or alongside routers, Pydantic schemas, and auth—so the agent does not hand-roll sync Session code or fragile relationship access in an async stack. The snippets emphasize engine configuration, session factory defaults, and Mapped-column models with timestamps and foreign keys, which are the usual gaps when greenfielding an API service. It is reference-oriented procedural knowledge rather than a full project generator, best paired with your own migrations and FastAPI dependency wiring.3.5kinstalls20Python ProPython Pro is a reference-oriented agent skill for solo builders shipping async Python—APIs, workers, and CLIs that talk to networks and databases. It encodes idiomatic asyncio patterns: single-task await flows, gathering many coroutines safely, and TaskGroup-based structured concurrency on Python 3.11+. The snippets emphasize modern typing (collections.abc.Coroutine, explicit return types) and practical resilience when one task in a batch fails while others succeed. Install it when your agent otherwise generates blocking calls, naked create_task sprawl, or gather without exception policy. It is not a full framework tutorial; it is procedural knowledge you paste into implementation sessions for backend Build work. Pair with your project's HTTP client and ORM choices—the skill stays at the concurrency layer. Confidence is high on async sections present in SKILL.md; expand tagging if the full skill adds sync, packaging, or testing chapters.3.5kinstalls21Pandas ProPandas Pro is an agent skill that packages deep pandas 2.0+ guidance for solo builders who need trustworthy aggregations without re-reading docs every sprint. The ingested reference centers on GroupBy mechanics, named aggregations, multi-column grouping, and pivot-style summaries—the same operations behind revenue rollups, funnel cohorts, and support ticket stats. Invoke it when you are exploring a CSV export, building an internal dashboard query, or preparing train/test feature summaries inside a SaaS or CLI analytics script. It is not a full ML pipeline skill; it sharpens the transform-and-summarize layer that sits between raw logs and decisions. Use it in Grow when you interpret user behavior, in Build when you embed analytics in backend jobs, and in Validate when you sanity-check prototype datasets before committing to schema or pricing assumptions grounded in numbers.3.3kinstalls22Shopify ExpertShopify Expert is an agent skill for solo and indie builders shipping on Shopify who need senior-level guidance across themes, apps, and headless commerce without guessing platform rules. It walks you from requirements through architecture setup with Shopify CLI, then into Liquid templates, GraphQL Storefront queries, app configuration, and checkout extensions. Use it when you are customizing a theme, creating a Shopify app, building Hydrogen or a custom React storefront, or integrating third-party services. The skill ties together implementation details practitioners usually scatter across Liquid docs, app manifests, and API references so your agent produces code-shaped output that matches Shopify’s constraints. It pairs naturally with GraphQL and React skills when you go headless, and it fits anywhere you are turning a validated store idea into a working merchant experience on Shopify’s stack.3.3kinstalls23Javascript ProJavaScript Pro is a specialist implementation skill for writing, debugging, and refactoring JavaScript using ES2023+ features, Promise-based async flows, and modern module systems in both browser and Node environments. Solo builders reach for it when shipping vanilla JS without a framework safety net, optimizing Fetch and Worker-heavy clients, or standing up small Node APIs. The documented workflow starts by reading package.json, module format, and runtime targets, then designs module boundaries and error handling before coding and running eslint --fix for validation. It aligns with agentic code review on .js/.mjs/.cjs assets and pairs conceptually with fullstack-guardian for cross-cutting stack checks. Intermediate complexity reflects expectations around event loops, module interop, and performance profiling rather than tutorial-level syntax alone.3.3kinstalls24Nextjs DeveloperNext.js Developer is an agent skill that encodes App Router architecture for solo builders shipping React sites on Next.js 14-era conventions. It documents the required root layout, nested dashboards, marketing route groups that omit URL segments, and advanced patterns such as parallel routes and catch-all blog segments so agents generate consistent folder trees instead of Pages Router leftovers. Examples cover Metadata exports, font loading, shared dashboard shells, and API Route Handlers under app/api. Use it when you are actively coding the product surface—landing adjunct pages, authenticated dashboard areas, and lightweight backend endpoints in one repo. The skill is reference-heavy procedural knowledge meant to keep Cursor, Claude Code, or Codex aligned on file names and segment rules while you iterate UI and data fetching.3.3kinstalls25Security ReviewerSecurity Reviewer is an agent skill oriented around infrastructure and DevSecOps guardrails for teams shipping on AWS, Azure, Kubernetes, and Terraform-backed repos. It gives copy-paste CI pipelines that chain static analysis, secret detection, and filesystem vulnerability scans on every push and pull request, plus CLI workflows to scan IaC directories and deployment YAML before merge. Cloud sections walk through enabling detective controls, tightening object storage exposure, and enforcing account password policies, with parallel Azure enablement steps. Solo builders use it when they wear the security hat without a dedicated AppSec team: you get repeatable commands and YAML instead of ad-hoc checklist chats. Pair it with your existing build and operate practices when you need evidence that critical findings were triaged before production promotion.3.3kinstalls26Database Optimizerdatabase-optimizer is an agent skill that walks solo and indie builders through practical relational index design and remediation. It targets PostgreSQL and MySQL workloads where mean query time or sequential scans on large tables signal missing or mis-ordered indexes. The workflow starts by mining pg_stat_statements, pg_stat_user_tables, and MySQL full-table-scan views to prioritize tables and queries that burn the most cumulative time. From there it prescribes single-column B-trees for filters, joins, and sorts, plus composite indexes with selective columns first and clear notes on which predicate shapes composite keys cannot serve. Builders shipping APIs, SaaS backends, or internal tools use it when ORM-generated SQL suddenly crawls in staging or production and they need opinionated SQL they can paste into migrations or run in a maintenance window. It does not replace formal query planners or vendor-specific advisors; it compresses common index strategy into agent-ready steps so one person can fix perf without hiring a DBA first.3.3kinstalls27Kotlin SpecialistKotlin-specialist is an agent skill aimed at solo and indie builders shipping Android apps with modern Google stack choices. It encodes practical Jetpack Compose snippets—cards, columns, buttons, theme typography—and ties them to ViewModel-driven state using StateFlow, so generated code matches common production structure. Use it when you are implementing profiles, lists, or form screens, wiring UI to a repository, or standardizing how loading and errors surface in composables. The skill reduces back-and-forth on boilerplate imports, Material 3 usage, and the unidirectional data flow pattern most Android codebases expect. It stays in the Build phase because it is implementation knowledge, not Play Store launch, analytics, or backend API design—though it assumes you will connect to your own data layer.3.2kinstalls28Playwright ExpertPlaywright Expert is a MIT-licensed specialist agent skill for solo builders shipping web products who need maintainable end-to-end browser tests. It walks a deliberate workflow: clarify user flows, configure Playwright correctly, implement tests with the Page Object Model and resilient selectors, debug failures using traces when tests flake, and wire the suite into CI/CD. Trigger it for Playwright setup, E2E scripts, page objects, fixtures, reporters, API mocking, or visual regression work. Reference guides load contextually for selectors, page objects, and related topics so the agent does not improvise locator anti-patterns. The skill targets the Ship phase testing shelf but remains useful whenever UI confidence blocks a release. Output is production-oriented test code and integration guidance aligned with quality-domain scope rather than one-off chat snippets.3.2kinstalls29Code DocumenterCode Documenter is a jeffallan Claude skill that teaches how to document HTTP APIs in FastAPI and Django REST so OpenAPI or schema tools can generate accurate reference material. Solo builders reach for it when an API is taking shape but external docs, client SDKs, or agent consumers need consistent summaries, tags, status codes, and field examples without maintaining a parallel YAML spec. The FastAPI section walks through endpoint decorators, Pydantic model documentation, router organization, and Args/Returns/Raises docstring structure; the Django portion continues into DRF-oriented documentation practices implied by the drf-spectacular heading in the skill body. It suits indie SaaS and internal API projects where one developer owns routes and docs together. It does not replace product marketing copy, run security review, or deploy documentation sites—it sharpens the code-level contracts that downstream doc portals and IDE tooling consume.3.1kinstalls30Terraform EngineerTerraform Engineer is a jeffallan skill that encodes infrastructure-as-code discipline for solo builders maintaining AWS-style Terraform (modules, locals, data sources, tagging). You invoke it when HCL has sprouted duplicate VPCs, frozen AMI IDs, or inconsistent tags across staging and production, and you want agent help applying DRY patterns without hiring a platform team. The readme walks concrete refactors: wrapping repeated networking in modules, centralizing tags and name prefixes in locals, and replacing brittle constants with data sources. It supports multi-environment SaaS and API backends where one person still owns `terraform plan` before releases. Secondary value appears in Ship launch prep when you are hardening infra before go-live. It is not a full module library install, a state-backend setup guide, or a compliance audit—it teaches procedural HCL structure your repo can adopt incrementally.3.1kinstalls31Nestjs ExpertNestJS Expert is a backend-focused agent skill that supplies copy-ready TypeScript patterns for JWT authentication in NestJS applications. It walks through Passport JwtStrategy configuration, bearer token extraction, payload validation, and a custom JwtAuthGuard that respects a Public metadata decorator for open endpoints. Solo builders shipping SaaS or internal APIs use it when scaffolding auth instead of guessing Nest guard lifecycle or reflector usage. The excerpts assume @nestjs/passport, @nestjs/config, and standard JWT payloads with sub, email, and role fields. It is a reference skill for the build phase—not a full migration guide, test suite, or refresh-token story—so you still own secrets management and user lookup in validate(). Pair it with your existing module structure and wire providers in auth modules as your repo requires.3.1kinstalls32Fullstack GuardianFullstack Guardian is a standards-oriented agent skill that keeps solo builders aligned on RESTful API conventions when they ship HTTP backends without a platform team reviewing every route. The embedded guidance walks through collection versus resource URLs, nested resource patterns, and which HTTP verbs pair with which success and error status codes—from 201 Created on POST through 422 validation failures and 429 rate limits. It also prescribes a structured ApiError shape so clients and agents can parse failures consistently. Use it while scaffolding new endpoints, refactoring inconsistent routes, or reviewing PRs where status codes and error bodies drifted. It is reference and checker material rather than a code generator: your agent applies the rules to the API you are building. Pair it with tests and OpenAPI docs when you harden contracts for production.3.1kinstalls33Game DeveloperGame Developer is an agent skill that teaches solo and indie builders a clean Entity Component System layout in C#, the pattern behind many performant 2D and 3D engines. Components hold pure data structs—position, velocity, health, and tag markers—while systems encapsulate frame logic such as integrating velocity into position across spans for cache-friendly updates. The included World sketch shows how to assign entity IDs and map components in dictionaries, a approachable stepping stone before adopting a full ECS framework like DOTS or a custom arch. Use it when you outgrow monolithic GameObject scripts, need deterministic simulation tests, or plan many entity types sharing movement and combat rules. The skill is reference architecture, not a complete engine; pair it with your renderer, input, and asset pipeline choices as you build levels and ship builds.3kinstalls34Cpp ProCpp Pro is a phase-specific agent skill aimed at solo and indie builders who need production-grade C++ structure instead of copy-pasted snippets. The documented material centers on modern CMake: declaring CXX-only projects, enforcing C++20 without extensions, exporting compile_commands for clangd and other tools, and splitting work into reusable library targets with correct PUBLIC/PRIVATE include semantics. It shows how to wire dependencies through FetchContent with pinned tags, link imported targets cleanly, gate platform-specific warning flags, and hook in testing plus install rules for libraries, headers, and binaries. Use it while you are actively building native backends, CLI tools, or embedded-style components where compile hygiene and reproducible builds matter as much as algorithms. It does not replace domain-specific concurrency or graphics expertise, but it gives your coding agent a consistent blueprint for repo layout and toolchain discipline that scales from side projects to shippable native services.3kinstalls35Monitoring ExpertMonitoring Expert equips solo and indie builders operating small SaaS or API stacks with copy-ready Prometheus alerting patterns instead of reinventing PromQL from scratch. The skill documents grouped rules for application health—5xx error ratio over five minutes, p95 latency above one second, and instance down via `up`—plus infrastructure pressure on memory above ninety percent and CPU above eighty percent with explicit `for` windows to reduce noise. Each alert carries severity labels and annotation summaries suitable for on-call runbooks or Grafana-on-Call routing. Use it when you ship to Kubernetes, VMs, or managed containers and need a baseline alerts.yml before tuning SLOs. It does not replace your metrics pipeline or dashboards; it accelerates the alert layer so you can iterate thresholds after you see real traffic.3kinstalls36React ExpertReact Expert is an agent skill that encodes production-ready React hooks patterns—data fetching with abort cleanup, debounced queries, and persisted client state—for solo builders shipping dashboards, extensions, or mobile web apps with Claude Code, Cursor, or Codex. Install it when you are in the build phase and need consistent hook structure instead of one-off useEffect spaghetti. The skill emphasizes TypeScript-friendly examples you can drop into components during frontend work. It does not replace a full design system or routing architecture; it accelerates everyday state-and-data problems indie teams hit on every sprint. Pair it with testing and review skills before ship when hooks touch auth or billing APIs.3kinstalls37Prompt EngineerPrompt-engineer is a context-management reference skill adapted from community context-engineering work, aimed at solo and indie builders who ship products with Claude Code, Cursor, Codex, or similar agents. It treats the context window as a scarce attention budget and teaches you to raise signal-to-noise ratio by balancing static system rules, demonstrations, growing chat history, and per-query RAG. You reach for it when complex agents with large windows start ignoring instructions, hallucinate mid-session, or get expensive because irrelevant tokens crowd out what matters. The skill walks through how each context component should persist or refresh, when to delimiter-tag instructions versus data, and how retrieval quality ties directly to reasoning errors. It is methodology, not a single integration: use it while designing a new agent skill, before a long implementation sprint, when tightening production prompt packs, or when debugging flaky agent behavior after ship. Outcomes are clearer prompt architecture, cheaper long sessions, and repeatable structure you can embed in SKILL.md and system prompts across the journey.3kinstalls38React Native ExpertReact Native Expert is an agent skill for solo and indie builders shipping cross-platform apps with Expo and Expo Router. It encodes the file-based routing model: where _layout.tsx files live, how (tabs) and (auth) groups isolate navigation chrome, and how dynamic routes like details/[id] should be registered in a root Stack with modal presentation when appropriate. When you are past Validate prototype and into Build, agents often hallucinate Next-style folders or mix React Navigation boilerplate with Expo Router 3+ conventions—this skill steers toward the canonical app/ directory structure and TypeScript layout snippets you can paste and adapt. It is phase-specific to mobile frontend work: pairing with backend or Firebase integration skills happens elsewhere. Complexity is intermediate because you should already have Node, Expo CLI, and a repo initialized. Outcomes are consistent route trees, fewer 404 and +not-found surprises, and faster iteration when adding settings stacks or auth gates. Not a substitute for EAS build pipelines, store compliance, or perf profiling in Ship.3kinstalls39Test MasterTest Master is an agent skill that teaches advanced test automation framework patterns for solo and indie builders shipping web or API products. It walks through the Screenplay pattern—Actors performing Tasks—for separation of concerns beyond page object models, keyword-driven tables that map human-readable steps to code for stakeholders who do not write TypeScript, and model-based testing where state machines define valid transitions and catch impossible UI paths early. Use it when your suite is growing past copy-paste selectors, when you want clearer intent in E2E specs, or when you need a path toward data-driven cases without rewriting the runner. The skill fits teams on Playwright-style tooling and values maintainability over one-off scripts. It does not replace a CI runner or flaky-test triage; it gives you architectural recipes your coding agent can apply while you implement features in Build and gate releases in Ship.3kinstalls40Microservices ArchitectMicroservices Architect is a reference agent skill that walks solo and indie builders through inter-service communication design end to end. It explains when to use REST for public CRUD, gRPC for low-latency typed internal calls, and GraphQL when clients need flexible aggregation across services. The guide continues into asynchronous messaging with Kafka for event streaming, RabbitMQ for flexible routing, and SQS for managed queues, including delivery guarantees and consumer patterns. Resilience sections cover client timeouts, bounded retries, circuit breakers, and bulkheads so partial outages do not cascade. Distributed workflow content contrasts saga choreography and orchestration, compensation, and idempotency for safe retries. Observability guidance ties correlation identifiers, distributed tracing, and RED metrics to day-two operations. Use it while decomposing a monolith or hardening an existing service mesh conversation, not as a one-click deploy pack.2.9kinstalls41Secure Code Guardiansecure-code-guardian is a reference skill for solo builders implementing authentication without relearning OWASP basics from scattered blog posts. It packages TypeScript patterns for bcrypt hashing at twelve rounds, structured password validation with explicit error messages, and JWT access versus refresh tokens with short-lived access and week-long refresh semantics. Install it during Ship security reviews or while building backend auth so your agent proposes consistent, reviewable code instead of inventing weak defaults. The skill is template-oriented: you still must wire routes, storage, rotation, and threat modeling, but the cryptographic and format guardrails are spelled out. It fits SaaS and API products where a single developer owns both implementation and security checklist. Works with Claude Code, Cursor, and Codex when your stack is Node/TypeScript. Pair with broader review skills after first integration to catch authorization logic gaps these snippets do not cover.2.8kinstalls42Dotnet Core Expertdotnet-core-expert is an agent skill for solo and indie builders implementing .NET 8 backends with ASP.NET Core minimal APIs, clean architecture layers, and cloud-native microservice patterns. Invoke when you need Entity Framework Core modeling, CQRS with MediatR, JWT authentication, or AOT-aware project setup rather than generic coding chat. The workflow forces compile-and-test gates: run dotnet build after implementation changes and dotnet test before treating work as done, with optional endpoint checks via curl or a REST client. It positions itself as a backend specialist with implementation scope and code output, surfacing a reference table for loading minimal API and related guidance on demand. Best when requirements imply performance-conscious C# services with explicit security and test coverage; less ideal when you only need a one-off script outside the .NET stack or pure infrastructure Terraform with no application layer.2.8kinstalls43Csharp DeveloperC# Developer is a reference skill for solo builders shipping ASP.NET Core backends without spelunking Microsoft docs on every session. It encodes a Minimal API-first layout: register SQL Server EF Core contexts, scoped repositories and services, Swagger for development, then map grouped endpoints with authorization and OpenAPI metadata. The included Product endpoints demonstrate consistent status codes, validation problem responses, and clean extension methods so agents generate cohesive APIs instead of one-off controllers. Install it when you are in active Build work on a .NET SaaS or internal API and want Claude Code or Cursor to follow the same DI and routing conventions across features. It assumes you already chose SQL Server and standard ASP.NET middleware; it does not replace security review or deployment automation. The patterns favor small teams that want vertical slices and endpoint groups over heavyweight MVC boilerplate.2.8kinstalls44Rails ExpertRails Expert is a reference skill for solo and indie builders shipping Ruby on Rails SaaS or API backends with Claude Code, Cursor, or similar agents. It packages copy-ready Active Record models—has_many, belongs_to, attachments, scopes, and validations—so agents stop inventing fragile associations. The readme stresses practical query performance: spotting N+1 loops and replacing them with includes for single and nested associations, plus joins when filtering without loading extra records. Use it whenever you are scaffolding models, refactoring controllers that touch associations, or reviewing agent-generated Rails code before merge. It does not replace migrations, deployment, or full architecture decisions; it tightens the data layer patterns agents emit during Build. Intermediate familiarity with Rails naming and MVC helps you adapt snippets to your domain.2.8kinstalls45Angular ArchitectAngular Architect is an agent skill for solo and indie builders shipping Angular 17+ applications who want consistent modern patterns instead of mixed legacy module code. It teaches standalone components with explicit import arrays, signal-based state with computed derivations and effects, and signal-first inputs and outputs including two-way model bindings. The readme emphasizes OnPush change detection alongside these patterns so agents do not default to brittle default change detection in new features. Use it when scaffolding feature components, migrating toward standalone APIs, or reviewing PRs for Angular idioms. It is pattern reference material—not a full CLI generator—so the agent applies the snippets to your existing folder structure and routing. Pair it with your project’s lint and testing setup so signal updates and async flows stay correct under OnPush.2.8kinstalls46Debugging WizardDebugging Wizard is a journey-wide agent skill that encodes how experienced developers recognize and fix recurring defect shapes before you burn hours on random edits. A pattern table links symptoms—intermittent failures, missing array ends, undefined property access, climbing memory, slow N+1 data paths, loose equality surprises, wrong loop captures, and stale UI state—to likely root causes and concrete before/after code. Solo builders benefit whenever an agent-assisted session turns into “why is this flaky?” whether you are finishing a feature, hardening before launch, or triaging user reports in production. It does not replace structured logging or test suites; it steers the conversation toward await discipline, bounds checks, optional chaining, cleanup in useEffect teardowns, and strict equality. Invoke it early when stack traces look familiar but the fix is not obvious, so the agent proposes targeted patches instead of speculative refactors.2.8kinstalls47Cli DeveloperCLI Developer is an agent skill that encodes opinionated CLI design patterns for solo and indie builders shipping terminal tools alongside AI coding agents. It walks through how to lay out root commands, nested subcommands, and plugin-style extensions so users can discover capabilities without memorizing syntax. Flag conventions cover boolean presence flags, required positional arguments versus optional flags, and multiple-value options that mirror how mature CLIs like git and npm behave. The configuration section is especially practical for one-person teams: it orders overrides from explicit CLI intent through environment variables, project and user config files, system paths, and defaults, with a merge example builders can paste into Node or adapt to other stacks. Use it when you are naming commands, debating flag shapes, or wiring config before you write parser code. It does not replace choosing a CLI framework, but it keeps agent-generated CLIs consistent enough to ship and document.2.8kinstalls48Sre EngineerSRE Engineer is an agent skill aimed at solo builders and tiny teams who own production without a full site-reliability org. It centers on the Google SRE idea that toil—manual, repetitive, automatable work that grows with traffic—should be measured and driven down. The skill supplies concrete structures: enumerated toil categories, a ToilItem record for frequency and minutes per occurrence, derived weekly and annual hour metrics, and an ROI score that favors high-time, easy-automation wins. That turns vague “I spend too much time on databases” complaints into a sorted backlog your agent can turn into scripts, cron jobs, or IaC. Use it after launch when interrupts dominate, during Operate when planning the next automation sprint, or in Build when you want deploy and repair paths to be self-service from day one. It complements monitoring skills by focusing on elimination of repeat manual steps rather than dashboards alone.2.8kinstalls49Rag ArchitectRAG Architect is an agent skill that helps solo builders choose chunking and retrieval strategies before wiring embeddings and vector stores into Claude Code, Cursor, or Codex workflows. The README centers on a strategy comparison matrix—fixed-size through agentic and late chunking—with explicit best-for and avoid guidance for logs, articles, technical manuals, and unstructured text. Use it when retrieval quality or context bleed is blocking your agent MVP, not when you only need a generic embed-and-dump tutorial. It stays in the build phase as agent-tooling: you are designing how documents become searchable units and how precision trades off against ingestion speed and cost. Pair it with integration skills for specific frameworks after you lock a chunking approach.2.8kinstalls50Cloud ArchitectCloud Architect is a dense AWS architecture reference skill aimed at solo and indie builders who must make credible infra decisions without a platform team. It organizes guidance around the Well-Architected Framework’s six pillars so sessions do not collapse into random service laundry lists. You get operational excellence habits—Infrastructure as Code, CI/CD, runbooks, game days—alongside security baselines, multi-AZ reliability, performance caching and serverless options, and explicit cost optimization moves. The readme is reference-oriented: your agent uses it when you are sketching a new API on Lambda versus ECS, hardening IAM and encryption, or planning failover and backups before launch. Complexity is advanced because AWS surface area is large and tradeoffs depend on workload shape. It spans Build when designing backends and Ship or Operate when reviewing prod readiness, but the canonical Prism shelf is Build backend for initial architecture work.2.7kinstalls51Vue Expertvue-expert is a senior frontend specialist skill for solo builders shipping on Vue 3. It starts from requirements—component hierarchy, state, and routing—then designs composables and Pinia stores before implementing with Composition API and correct reactivity. Coverage spans Nuxt 3 for SSR/SSG, Quasar and Capacitor for mobile shells, PWA service workers, and Vite configuration including TypeScript integration and build performance. The workflow bakes in validation: run vue-tsc --noEmit, fix errors, and re-run until clean, optionally confirming behavior with Vue DevTools. Use when triggers mention Vue 3, Nuxt, Pinia, composables, or Vite Vue tuning rather than generic React guidance. It complements TypeScript-heavy stacks and pairs naturally with full-stack guardrails when API boundaries matter. MIT-licensed metadata v1.1.0 from the Jeffallan ecosystem.2.6kinstalls52Atlassian McpAtlassian MCP is an agent skill fragment focused on authentication patterns for connecting coding agents to Jira and Confluence through MCP-style integrations. Solo builders shipping SaaS or internal tools often need agents to file bugs, update pages, or sync specs, but Atlassian offers multiple credential models with different security postures. This skill maps OAuth 2.1 for user-facing Cloud apps, API tokens for personal automation, and PATs for Server or Data Center, while warning against legacy Basic Auth. It walks through registering an app, building the authorize URL with correct scopes such as read:jira-work and confluence content read/write, and exchanging the authorization code for tokens. Use it while implementing or hardening an Atlassian MCP server or custom integration so your agent uses consent-based OAuth where appropriate and least-privilege tokens elsewhere.2.5kinstalls53Swift ExpertSwift Expert is an agent skill that steers coding agents through modern Swift concurrency and Apple-platform idioms. Solo and indie builders shipping iPhone, iPad, or Mac apps use it when network calls, background work, or shared caches must stay correct under parallel execution without race bugs. The skill emphasizes async functions, await at call sites, task groups for fan-out work, and actors for encapsulating mutable cache and in-progress request maps. It fits mid-build refactors when legacy completion handlers or unstructured tasks need migration, and when agents might otherwise emit pre-concurrency patterns. Expect concrete Swift excerpts rather than generic language advice, so outputs stay compile-oriented and reviewable in Xcode. Pair it with your repo’s architecture (MVVM, TCA, etc.) and layer-specific skills for SwiftUI or Core Data when UI or persistence boundaries matter.2.5kinstalls54Salesforce DeveloperSalesforce Developer is an agent skill for solo and indie builders who extend Salesforce orgs with Apex instead of one-off trigger scripts. It walks through service-class structure, bulk-safe queries over parent-child relationships, and rating or rollup style updates that respect governor limits. Use it when your agent needs consistent patterns for with sharing classes, validation failures, and separating orchestration from controllers. The excerpts emphasize Map-based staging before DML and child relationship subqueries rather than SOQL-in-loops. It matters on Prism because CRM-heavy products still need citable, repeatable Apex guidance tied to the Build phase. Pair it with your org’s naming conventions and deployment pipeline; it does not replace security review or full test coverage strategy.2.4kinstalls55Fine Tuning ExpertFine-Tuning Expert is an agent skill focused on dataset preparation—the step most solo builders underestimate when they try to specialize a language model for support, codegen, or domain Q&A. It documents Alpaca-style instruction rows, ShareGPT multi-turn threads, and OpenAI-compatible message arrays, plus the mindset that formatting and cleanliness beat marginal architecture tweaks. Install it when you are past prompt engineering and need thousands of consistent examples before calling a fine-tuning API or open-source trainer. The reference walks through representative Python snippets for structure and conversion, helping agents spot missing fields, role mismatches, and leaky duplicates early. For indie builders shipping an agent with a owned tone or compliance boundaries, this skill turns vague “collect chats” goals into auditable JSON pipelines you can re-run as product copy changes.2.4kinstalls56Mcp Developermcp-developer is a protocol-focused skill for solo builders creating MCP servers that Claude Desktop, Cursor, and other clients can call. It walks through JSON-RPC 2.0 envelopes, tools/list result shapes with inputSchema, error codes, and server-to-client notifications like resources/updated. You also get the ordered connection lifecycle—connect, initialize, initialized, normal traffic, ping keepalive, shutdown—so implementations match what real clients expect. That reduces broken handshakes and schema mismatches when you expose git, APIs, or files as tools. Use it while coding a new server in Build, when validating an integration before Ship, or when tracing Operate incidents where tools stop listing or notifications never fire. It is specification literacy packaged for agents, not a hosted MCP marketplace entry.2.4kinstalls57Feature Forgefeature-forge is a Claude skills package that teaches agents to write acceptance criteria in consistent Given-When-Then form with labeled scenarios such as successful login, invalid credentials, empty cart checkout, and session expiry. Solo builders who ship SaaS or mobile products without a dedicated QA lead use it to convert verbal feature requests into numbered AC-### blocks that double as manual test scripts and agent implementation checklists. The skill emphasizes three buckets—happy path, error handling, and edge cases—so scope conversations surface failures before code lands. It is documentation and template driven rather than a test runner: output is markdown-ready criteria you can paste into issues, PRDs, or test plans. Invoke it when a feature is agreed in principle but lacks observable behaviors, or when you want Cursor or Claude Code to implement against unambiguous expectations instead of improvising UX details.2.4kinstalls58Legacy Modernizerlegacy-modernizer teaches agents and solo maintainers how to modernize opaque legacy code without gambling on semantics. The showcased strategy is characterization testing: write pytest cases that record what the system does today, including edge combinations such as domestic versus international shipping, weight thresholds, and priority multipliers, before replacing implementation details. That approach suits indie SaaS with years of accrued business rules, internal APIs whose authors left, and brownfield services where requirements live only in code paths. Use the skill when you plan refactors, extractions, or language upgrades and need a safety net stronger than hope. It pairs naturally with code review and incremental extraction workflows. You end with a executable specification of legacy truth that fails loudly when behavior drifts—freeing you to simplify structure while preserving customer-visible outcomes until you deliberately fix documented bugs.2.3kinstalls59Vue Expert JsVue Expert JS is a frontend agent skill that encodes Vue 3 Composition API conventions for builders who stay in JavaScript with script setup instead of a TypeScript-heavy stack. It documents how to declare props with required flags, sensible defaults, factory defaults for arrays and objects, and string validators for size-like enums; how to emit events with either string lists or validation functions that guard payload shapes; and how to implement v-model for a single modelValue stream or multiple bound fields such as firstName and lastName. JSDoc typedef blocks give IDE hints where TypeScript is absent. Solo developers install it when an agent is drafting or refactoring SFCs and tends to mix Options API habits with incomplete emit contracts. The skill is reference-shaped procedural knowledge—patterns and snippets—not a linter integration or a design system. Use it during active UI build work; skip it when the codebase is Vue 2 Options-only or another framework entirely.2.3kinstalls60Django Expertdjango-expert is an agent skill that packages Django REST Framework authentication recipes a solo builder can drop into settings.py and urls.py. It focuses on rest_framework_simplejwt: default authentication classes, SIMPLE_JWT timing and rotation flags, Bearer header types, and the standard token and refresh routes. The skill also shows how to extend tokens with custom claims via get_token on a subclassed TokenObtainPairSerializer, and it introduces custom DRF permissions such as owner-or-read-only patterns for protecting writes. Install it when you are building a Python API and need JWT login that matches common production defaults instead of improvising auth in chat. It does not replace threat modeling or OWASP review—that belongs in Ship—but it accelerates the first secure-looking auth slice so you can ship endpoints and iterate on roles later.2.3kinstalls61Spec Minerspec-miner is an agent skill that turns codebase spelunking into a repeatable mining workflow for solo builders inheriting brownfield repos or evaluating acquisitions. It supplies a table-driven checklist spanning entry points, routing, models, authentication guards, validation pipes, error handling, outbound HTTP, configuration, tests, and background workers—each with concrete glob and grep hints such as **/routes/**/*, @Entity, and Bull queues. Work proceeds in four phases: structure discovery, API surface documentation, data-layer mapping including migrations and relationships, and business-logic tracing with external integrations. Use it when you need a written picture of reality before rewriting, estimating, or handing work to an agent. Outputs support validate-time scope decisions and build-time planning; it is research discipline, not a code generator.2.3kinstalls62Graphql ArchitectGraphql-architect is an agent skill that walks solo builders through Apollo Federation-style GraphQL system design: subgraph schemas, entity keys, reference resolvers, and TypeScript server bootstrap code. It fits when you have outgrown a single GraphQL monolith and need multiple teams—or multiple agent sessions—to own bounded contexts without breaking the supergraph contract. Install it during backend build work when you are naming entities, choosing @key fields, and wiring __resolveReference so the gateway can stitch users, products, and related types reliably. The readme emphasizes copy-pasteable patterns rather than abstract theory, which helps indie founders who are learning federation while shipping. You can revisit the same skill in ship when reviewing whether new fields belong in an existing subgraph or need a new service boundary. It does not replace performance tuning, security review of public schemas, or choosing REST instead of GraphQL for very small apps.2.3kinstalls63The FoolThe Fool is a journey-wide agent skill that applies court-jester clarity—speaking truth without politeness—to ideas, plans, and decisions. Solo builders install it when enthusiasm outruns evidence: before you lock scope, pick a stack, or ship a fragile architecture. The workflow restates your position as a steelmanned thesis, lets you pick a challenge mode through guided questions, then runs structured critique across devil’s advocate, pre-mortem, red team, and related methods to expose unstated assumptions and weak proof. It is not implementation help; it is decision hygiene usable in Validate when narrowing scope, in Build when reviewing design bets, in Ship when red-teaming launch plans, and in Operate when questioning runbooks. Use it alongside deeper review skills when you need a deliberate adversarial pass rather than polite agreement from the agent.2.3kinstalls64Chaos EngineerChaos Engineer is a Claude skill for solo builders and small teams running distributed services who need disciplined resilience work—not random prod breakage. It walks through mapping system architecture and failure modes, defining hypotheses and steady-state metrics, constraining blast radius, and executing experiments via frameworks such as Chaos Monkey or Litmus Chaos. You get implementation-oriented artifacts: experiment manifests, runbooks, rollback steps, and post-mortem templates after game days or automated fault injection. The skill fits operators validating that retries, circuit breakers, and regional failover actually work under stress, and DevOps folks wiring selective chaos into CI/CD without jeopardizing revenue paths. Pair it with broader SRE or Kubernetes skills when your stack is container-heavy or multi-region.2.2kinstalls65Ml Pipelineml-pipeline is an agent skill that teaches reproducible machine-learning experiment tracking for indie builders shipping models or analytics features. It centers on capturing hyperparameters, metrics, artifacts, and model versions so every run can be compared and replayed. The reference walks through MLflow setup—including experiment creation, run logging, and a practical MLflowTracker wrapper—and points to Weights & Biases integration, registry workflows, and custom trackers when you outgrow defaults. Use it when you are standing up tracking on localhost or a shared server, defining registry conventions, or choosing between hosted and DIY stacks. Skip it for throwaway notebooks without parameters or pure application code with no training loop. For solo agents in Claude Code or Cursor, it turns vague "train a model" requests into concrete, auditable pipeline steps aligned with production-minded ML practice.2.2kinstalls66Spark Engineerspark-engineer is an agent skill focused on Apache Spark DataFrame partitioning and caching fundamentals for builders running PySpark on small teams or constrained clusters. It explains why partition count drives parallelism, locality, memory safety, and join performance, then gives actionable sizing tables and formulas tied to executor cores and data volume. You learn when to repartition (full shuffle) versus coalesce, how to partition by keys such as user_id and date for co-located joins, and how to aim for roughly 128–256MB partitions to reduce OOM risk. The material suits ETL pipelines, feature stores, and analytics backends agents scaffold in Python. It is not a full Spark ops or streaming catalog entry—it narrows to partition and cache decisions that commonly block indie data jobs. Pair it with cloud cluster provisioning skills separately when you are choosing instance types or autoscaling policies.2.2kinstalls