giuseppe-trisciuoglio/developer-kit
98 skills137k installs26.6k starsGitHub
Install
npx skills add https://github.com/giuseppe-trisciuoglio/developer-kitSkills in this repo
1Shadcn Uishadcn/ui is an agent skill that teaches procedural patterns for the popular copy-in UI kit built on Radix UI and Tailwind CSS—aimed at solo builders who want a professional SaaS or ecommerce interface without maintaining a separate component package. Invoke it when you are initializing shadcn in a React or Next app, pulling components with the shadcn CLI, composing accessible buttons, dialogs, sheets, dropdowns, toasts, data tables, or chart blocks, or wiring complex forms with React Hook Form and Zod. Because components live in your codebase, the skill emphasizes installation commands, configuration, theming via CSS variables, and dark mode—not black-box imports. It fits the Build frontend phase exclusively for typical indie workflows: you are still shaping the product surface, not running SEO or lifecycle campaigns. The skill allows Read, Write, Bash, Edit, and Glob so agents can scaffold files and run npx adds responsibly. Expect intermediate complexity if you already use Tailwind; beginners can follow CLI steps but should read generated component code. Use this skill when user language matches shadcn, Radix, accessible components, or validated form layouts—not when you only ne18kinstalls2Tailwind Css Patternstailwind-css-patterns in the developer-kit repo documents Tailwind CSS accessibility guidelines as copy-paste HTML examples rather than a full design system generator. Solo builders shipping landing pages, dashboards, or marketing sites use it while implementing buttons, dialogs, navigation, and dynamic notifications where WCAG expectations meet utility-first CSS. The material emphasizes focus management (including focus-visible versus focus), screen reader-only text, ARIA labeling for icon buttons, described-by links, and live regions for async updates. Color contrast sections remind you to pair background and text utilities so ratios stay within AA or AAA targets. It complements generic Tailwind layout skills by narrowing scope to inclusive UI primitives. Complexity is beginner to intermediate depending on how strictly you audit contrast and keyboard flows. Treat it as a pattern reference during frontend build work, then validate with your own accessibility checklist or automated audits before ship.12kinstalls3Unit Test Bean Validationunit-test-bean-validation is a Java-focused agent skill from developer-kit that teaches how to unit-test Jakarta Bean Validation without spinning up Spring MVC. Solo builders shipping JVM APIs learn to assert ConstraintViolation property paths, run validator.validate with group interfaces for create versus update flows, and collapse repetitive cases into parameterized tests. The reference patterns reduce flakiness compared to only testing validation through controller integration tests. Use it when DTOs carry @NotNull, @Min, or custom constraints and you need fast feedback in CI. It complements broader testing skills but stays narrow on Validator API usage. Expect intermediate Java and familiarity with AssertJ-style assertions.2.3kinstalls4React PatternsReact Patterns is a concise agent skill from the developer-kit that teaches solo builders how to structure components the way production React codebases expect: explicit TypeScript interfaces for props, sensible defaults, children for layout composition, and lifting shared state to the nearest common ancestor when siblings must stay in sync. It is not a full design system— it is procedural knowledge for recurring UI shapes like buttons with variants and multi-panel selectors. Indie developers shipping SaaS dashboards, browser extensions with React UI, or hybrid mobile web views benefit when their agent otherwise invents inconsistent prop APIs or buries coordination logic inside leaf components. Invoke while scaffolding features, refactoring duplicated markup, or reviewing agent-generated components for maintainability. The examples emphasize readable patterns over framework magic, making it a good companion during Build before you add routing, data fetching, or testing layers.2.1kinstalls5Nextjs PerformanceNext.js Performance is an agent skill from the developer-kit that teaches solo builders how to implement optimized Route Handlers in the App Router. It covers baseline GET and POST endpoints, cache and revalidation directives, and production-minded error responses so API routes stay predictable under load. The skill walks through enabling the Edge runtime for geographically distributed handlers with region hints, which matters when you want search or proxy-style endpoints close to users without standing up a separate edge service. It also documents streaming response patterns on POST, which helps when you are piping tokens, chunks, or large bodies without buffering everything in memory. The material is written as concrete TypeScript examples you can drop into `app/api/**/route.ts`, making it useful while you are still wiring backend behavior rather than only during a late perf audit. If you are shipping a SaaS or content app on Next.js and want API routes that respect Next’s caching model and runtime options, this skill gives a focused checklist of patterns instead of scattering notes across docs.1.6kinstalls6Typescript Docstypescript-docs is an agent skill for solo builders who need production-grade TypeScript documentation without hand-rolling every convention. It combines inline JSDoc, generated API reference via TypeDoc (and Compodoc for Angular), and ADRs so technical and product readers each get the right layer. The workflow covers configuration, framework-specific patterns across NestJS, Express, React, Angular, and Vue, ESLint rules to catch thin or missing docs, and CI with GitHub Actions. Use it when a repo is growing past readme-only explanations, when you are publishing a package or HTTP surface, or when you want decisions captured as ADRs alongside generated reference. It assumes a TypeScript codebase and standard Node tooling; it does not replace product marketing copy or OpenAPI-only stacks that skip TypeDoc entirely.1.5kinstalls7NestjsNestJS Best Practices is a compact agent skill that keeps solo backends consistent: constructor injection instead of property injection, DTOs and validation pipes on every boundary, exception filters for errors, and focused modules with environment-based config. It extends into data layer guidance—connection pooling, migrations, soft deletes, transactions—and security habits like parameterized queries (noting Drizzle’s defaults), rate limiting, and hiding stack traces in production. A practical section walks installing Drizzle and Gel packages from the official Gel new-project path, so agents do not invent package names. Use it while generating or refactoring Nest services and controllers, not as a full Nest CLI tutorial. Pair it with your test and deploy skills when you move from greenfield modules to shipped APIs.1.5kinstalls8Drizzle Orm PatternsDrizzle ORM Patterns is an agent skill for solo builders and small teams who want a Postgres-, MySQL-, or SQLite-backed API without fighting an untyped query layer. It proactively covers table and constraint definition, relations, inserts/selects/updates/deletes, complex joins, aggregations, transactions, and migrations through Drizzle Kit. The skill maps each supported engine to the right core import and table helper so agents do not mix dialect APIs. Use it whenever you are scaffolding a new schema, refactoring relations, or adding migration files during active development. Intermediate complexity assumes comfort with SQL concepts and TypeScript. It delivers copy-ready patterns rather than replacing your ORM docs entirely—ideal when your coding agent needs consistent Drizzle idioms across modules. Pair with your test and deploy steps separately; this skill stays in the data layer build phase.1.5kinstalls9Unit Test Boundary ConditionsUnit Test Boundary Conditions is a developer-kit reference skill packed with Java JUnit examples for the nasty edges solo backend builders hit: null reads on concurrent maps, structural changes while iterating copy-on-write lists, empty blocking queues, atomic counters near extremes, and synchronized increments. It fits the Ship testing phase when you are expanding coverage beyond happy paths—especially for APIs and services where race bugs slip through casual testing. The snippets assume JUnit Jupiter and AssertJ-style assertions, and include parameterized tests for multiple boundary inputs in one run. Use it as paste-ready patterns inside your test suite rather than as a runner integration; the agent applies the skill when you need systematic boundary coverage for JVM services you are about to ship or refactor.1.5kinstalls10Spring Boot Test PatternsSpring-boot-test-patterns is a developer-kit agent skill that teaches comprehensive testing approaches for Spring Boot apps using JUnit 5, Mockito, slice annotations, and Testcontainers. Solo builders shipping JVM APIs or SaaS backends invoke it when adding @Test methods, configuring @MockBean collaborators, or choosing between fast slices and slower full-context runs. The skill contrasts unit, repository, controller, and integration strategies with explicit timing guidance so CI stays fast while critical paths still hit real databases. It aligns with Spring Boot 3.5+ practices such as @ServiceConnection for container lifecycle. Use it during feature work or pre-release hardening when tests are missing, flaky, or overweight. It is procedural reference material—pair with your app's domain tests rather than expecting generated coverage without context.1.5kinstalls11Spring Boot Rest Api StandardsSpring Boot REST API Standards is an agent skill that teaches a feature-based, clean-architecture layout for Java REST services: domain models and repository ports free of framework code, application services and immutable request/response DTOs, presentation controllers with mappers and exception handling, and infrastructure JPA adapters. Solo builders shipping SaaS or internal APIs on Spring Boot use it to avoid a single flat package of annotations-heavy entities and to keep boundaries testable. The readme walks through concrete patterns—domain entities with value objects like Email, application services orchestrating use cases, and REST layers that map to DTOs rather than leaking persistence models. It fits intermediate builders who want consistent structure across features without adopting a full separate framework boilerplate generator.1.4kinstalls12Spring Boot Security Jwtspring-boot-security-jwt packages production-oriented patterns for securing Spring Boot REST APIs with JSON Web Tokens. It targets solo builders and small teams who need Spring Security 6.x wired correctly—not a generic “add JWT” snippet—covering generation and validation, refresh strategies, cookie versus Bearer clients, database-backed users, OAuth2 hooks, and expressive role or permission checks at the method layer. The skill activates when you are implementing login, protecting routes, or hardening an API that must stay stateless across instances. Expect guided use of Read, Write, Edit, Bash, Glob, and Grep to apply filters, properties, and entity models in a 3.5.x codebase. It complements Ship-phase security review but does not replace threat modeling, secret management policy, or penetration testing before production launch.1.4kinstalls13Spring Data JpaSpring Data JPA is a code-example agent skill aimed at solo builders and small teams shipping JVM backends who want copy-paste-correct entity mappings instead of trial-and-error Hibernate annotations. The documented pattern centers on a familiar catalog domain: categories owning products, with identity keys, column lengths, decimal price precision, stock defaults, and bidirectional association management including cascade and orphan removal on the one-to-many side. It also wires Spring Data auditing fields so created and updated timestamps are first-class columns—a common gap when agents generate bare entities without enabling JPA auditing in the application context. The skill is intentionally example-driven rather than a full framework course; your agent uses it when you ask for repositories, entity design, or relationship fixes during API build-out. Pair it with your own migration tool and service layer tests because the snippet stops at entity shape and does not replace transaction boundaries, DTO mapping, or query optimization review.1.3kinstalls14Spring Boot Openapi Documentationspring-boot-openapi-documentation is a procedural skill for indie Spring Boot APIs that outgrow a single swagger page. It walks through SpringDoc GroupedOpenApi definitions: path matchers for /api/public, /api/admin, and /api/user surfaces, package scans for split controller modules, and optional method filters tied to custom annotations. Global OperationCustomizer hooks let you stamp common parameters, security schemes, or response shapes once instead of annotating every endpoint by hand. Solo builders shipping REST or BFF services use it when frontend clients, partner integrators, or AI agents need trustworthy OpenAPI 3 documents that mirror real route boundaries. Place it in Build/docs while endpoints stabilize, then refresh groups as you add launch-facing public versus internal admin slices.1.3kinstalls15Drawio Logical DiagramsDraw.io Logical Diagrams is an agent skill that teaches your coding assistant to author professional logical diagrams in draw.io’s native XML format, focusing on abstract system structure and process flow instead of branded cloud tiles. Solo builders use it when they need BPMN process maps, UML views, data flow diagrams, branching decision charts, or component interaction sketches that stay readable for stakeholders and future agents without locking the narrative to AWS or Azure icon sets. The skill fits early validation conversations when you are still naming components, throughout Build when README and ADR-style visuals matter, and again in Ship when reviewers need a clear logical picture separate from deployment diagrams. Because output is standard .drawio files, you can open, diff, and iterate in diagrams.net or embedded editors. It pairs well with implementation work: the same agent session that writes services can emit matching logical architecture files. Complexity is intermediate—you need enough system clarity to label nodes and flows—but you do not need draw.io mastery upfront. Choose this skill when documentation must explain what talks to what, not which managed service1.3kinstalls16Clean ArchitectureClean Architecture is an agent skill that encodes Java-specific implementation patterns for Uncle Bob–style layering: immutable value objects as records with validation in canonical constructors, and domain events as sealed types so inheritance stays explicit and exhaustive. Solo and indie builders shipping JVM backends use it when an agent might otherwise generate anemic DTOs, leaky entities, or stringly typed events. The SKILL.md focuses on concrete snippets—email and address records, order-created events—not abstract theory, so you get actionable code during the Build phase. It pairs naturally with API design and repository ports elsewhere in a developer kit. Complexity is intermediate: you should already know packages, modules, and basic DDD vocabulary. It does not replace project scaffolding or dependency injection setup; it standardizes how domain primitives and events look in generated Java.1.2kinstalls17Spring Boot Crud Patternsspring-boot-crud-patterns packages opinionated Spring Boot CRUD structure for solo builders who want agents to scaffold APIs fast without guessing package layout. You describe entities—fields, IDs, and relationships like ONE_TO_MANY—in JSON specs similar to the bundled Order and Product examples, then run the generator to emit domain models, JPA entities, repository adapters, services, validated DTOs, and REST controllers under a feature folder. The quick reference locks HTTP status codes and validation expectations so agents do not return 200 on creates or skip jakarta.validation on inputs. Feature-scoped repository interfaces keep hexagonal boundaries clear between domain ports and Spring Data infrastructure. Ideal when you are standing up admin APIs, storefront backends, or internal microservices during Build and need repeatable boilerplate instead of copy-paste from blog posts. Customize templates-dir when your org naming diverges from the sample com.example.product tree.1.2kinstalls18Prompt EngineeringPrompt Engineering is a developer-kit skill for solo builders who depend on Claude, Cursor, Codex, or similar agents and need prompts that are clear, testable, and reusable—not one-off chat blobs. It centralizes the main workflow in SKILL.md and loads focused reference files for few-shot patterns, chain-of-thought structuring, system prompt design, and template composition only when needed. Triggers cover rewriting user prompts, fixing output format drift, adding reasoning scaffolds, and running measurable optimization passes. The skill treats prompt design as engineering: define when to use each pattern, select balanced example counts, and align system instructions with evaluation criteria. Because strong prompts underpin research summaries, codegen, reviews, and launch copy alike, it functions as journey-wide capability even though you typically install it while building agent tooling. Intermediate complexity reflects judgment calls on example selection and test design rather than syntax alone.1.2kinstalls19Spring Ai Mcp Server PatternsSpring AI MCP Server Patterns is an agent skill for indie builders who extend JVM backends with Model Context Protocol servers using Spring AI’s official annotations and auto-configuration. It walks through enabling an MCP server on Spring Boot, declaring tools and prompt templates agents can discover, documenting parameters for reliable tool calls, and choosing stdio versus HTTP or SSE for local IDE hooks versus remote deployment. The skill targets implementers adding custom business capabilities—CRUD, queries, workflows—to Claude Code, Cursor, or other MCP clients without ad-hoc REST wrappers. Use it when you are building AI tools on Java/Kotlin stacks, not when you only need a Python FastMCP prototype. Outcomes are copy-paste patterns aligned with Spring AI conventions so your server behaves predictably under security constraints and transport differences.1.2kinstalls20Chunking StrategyChunking-strategy is a reference skill for solo builders shipping RAG-powered agents, internal copilots, or SaaS search. The SKILL.md walks eleven chunking strategies—from low-complexity fixed-length baselines through semantic, agentic, and hybrid layouts—with a comparison table of complexity, use case, and benefit plus starter Python implementations. Install it when you are designing ingestion pipelines and need natural boundaries, overlap for continuity, hierarchical docs, or multi-modal splits instead of guessing chunk_size in isolation. It fits the Build phase backend work where retrieval quality is decided before you invest in evals and ship. Expect LangChain-oriented examples and tiktoken-aware sizing; you still own embedding choice, metadata, and evaluation. Advanced readers use it to justify sliding window or semantic chunking to stakeholders and to avoid shipping a demo that fails on long technical PDFs or mixed content types.1.2kinstalls21Unit Test Service LayerUnit Test Service Layer is an example-driven agent skill for solo builders shipping Spring-style Java APIs who need reliable tests around @Service classes without spinning up databases. It documents the standard Mockito plus JUnit 5 setup for Maven and Gradle, then walks through injecting mocks for repositories and collaborators so agents can scaffold tests that assert return values and interaction counts. The patterns favor fast unit boundaries—mock persistence, exercise business logic, verify calls—rather than full integration suites. Use it when your agent keeps writing brittle tests, missing @InjectMocks wiring, or inconsistent AssertJ assertions. It fits indie backends and small teams who already use @Service/@Repository layering and want ship-ready test coverage aligned with common Java ecosystem conventions.1.2kinstalls22Spring Boot CacheSpring Boot Cache is a reference-oriented agent skill for solo builders shipping Java APIs who need the Spring Cache abstraction spelled out in one place. It walks through CacheManager and Cache interfaces, lists common manager implementations from simple in-memory maps through Caffeine and Redis, and tabulates annotation usage so agents can apply @Cacheable and related decorators consistently. Use it while implementing read-heavy endpoints, tuning eviction, or choosing between local and distributed cache backends during the build phase. It does not replace provider-specific tuning guides but gives accurate API shapes and naming so migrations and new features do not break cache keys or conditions. Intermediate familiarity with Spring Boot is assumed; the skill is narrowly scoped to backend build work rather than launch or operations monitoring.1.2kinstalls23Spring Boot Resilience4jSpring Boot Resilience4j is an agent skill for solo and indie builders shipping JVM APIs who need production-grade fault tolerance without copying stale Stack Overflow snippets. It walks through Maven dependencies, application properties, and annotation-driven Resilience4j usage on Spring Boot 3.x so WebClient, RestTemplate, or repository calls gain circuit breakers, retries, rate limits, bulkheads, and timeouts. Use it when microservices or third-party integrations fail intermittently, when you must stop retry storms from amplifying outages, or when you want fallbacks that degrade gracefully instead of returning 500s to every client. The skill emphasizes configurable backoff, named resilience instances, and checking behavior via Actuator rather than guessing in production. It targets backend integration work during active development, with natural follow-up in ship and operate phases when you tune thresholds under real traffic.1.2kinstalls24Spring Boot ActuatorSpring Boot Actuator Auditing is an agent skill for solo builders shipping Java APIs who need security-relevant events emitted in a standard way once Spring Security is on the classpath. It walks through registering an AuditEventRepository bean, using the built-in in-memory store for development, and graduating to a persistent entity model for production audit retention. The focus is operational visibility—who failed login, who was denied—so you can report incidents or enforce lock-out rules without bolting on a separate audit product on day one. Use it when your Spring Boot service is already secured and you want Actuator’s audit framework configured deliberately rather than left at defaults you cannot query later.1.2kinstalls25Spring Boot Dependency InjectionSpring Boot Dependency Injection is an agent skill from the developer-kit that teaches solo builders and small teams how to wire Spring beans correctly using constructor injection—the pattern Spring recommends for mandatory dependencies. It walks through Lombok-backed @RequiredArgsConstructor services and explicit constructors with null checks, using realistic multi-bean services such as user registration with repositories, email, and password encoding. Install it when you are building or refactoring Java microservices and want your coding agent to stop defaulting to field injection or unclear @Autowired usage. The skill matters because sloppy DI makes unit tests painful, hides missing beans until runtime, and fights Spring Boot 3.x conventions. It is reference-oriented with copy-paste Java snippets rather than a full project scaffold, so pair it with your existing Spring module layout.1.2kinstalls26Spring Boot Event Driven PatternsSpring Boot Event-Driven Patterns is an agent skill for indie builders implementing Event-Driven Architecture on Spring Boot 3.x. It covers immutable domain events, in-process ApplicationEvent flows with transactional listeners that fire after commits, and distributed messaging through Kafka and Spring Cloud Stream. It also documents the transactional outbox pattern when you must not lose events if the database commits but the broker is down. Use it when replacing synchronous service-to-service calls, modeling DDD aggregate events, or standing up async pipelines without guessing Spring configuration. The skill expects Read, Write, Edit, and Bash tooling per its frontmatter, so agents may scaffold listeners and config files directly in your repo. It pairs naturally with dependency-injection and WireMock testing skills in the same developer-kit for a full backend loop.1.2kinstalls27Unit Test Wiremock Rest ApiUnit Test WireMock REST API is an agent skill that gives solo builders copy-paste JUnit patterns for stubbing downstream HTTP APIs during client or adapter tests. It covers not-found and server-error responses, exception mapping, and verifying that your code sends the correct JSON payloads and headers to partner services. Use it when you integrate third-party REST APIs in a Java codebase and cannot rely on flaky sandboxes in CI. The skill keeps tests fast and deterministic by running WireMock in-process rather than spinning up full environments. It assumes you already have an ApiClient or similar wrapper to point at the mock base URL. Depth is in assertion and stub DSL examples, so it complements Spring Boot service skills rather than replacing integration-test infrastructure setup.1.2kinstalls28Unit Test Controller LayerUnit Test Controller Layer is an agent skill from the developer-kit that teaches advanced Spring Web MVC controller testing with MockMvc, Mockito service stubs, and security expectations. Solo builders shipping Java APIs often under-test the HTTP boundary—this skill supplies copy-ready tests for happy path, not-found exceptions, missing auth, forbidden roles, and multipart uploads. You mock domain services, drive requests with perform(), and assert status and payload shape without spinning up a full integration environment. It fits indie SaaS backends on Spring Boot where controllers are thin and correctness means the right status codes and headers for every branch. Use it while hardening endpoints before launch or when refactoring controllers and you need parity with prior behavior. The patterns assume JUnit-style tests and standard Spring Security test setup; adapt package names and routes to your project.1.2kinstalls29Spring Data Neo4jSpring Data Neo4j is a pattern library skill for solo JVM builders shipping graph-backed APIs without re-reading the entire reference manual for every relationship annotation. It walks through realistic domains—a movie graph with incoming ACTED_IN and DIRECTED edges, social networks, and e-commerce catalogs—showing how to define @Node classes, @Relationship direction, and property mapping. Custom Cypher query sections help when derived query methods are not enough, and reactive examples suit WebFlux-style services. Testing snippets round out the flow so agents generate compilable entities instead of pseudo-graph code. Use it when you have committed to Neo4j for recommendations, permissions graphs, or knowledge links and need Spring Boot repository layers that match official SDN conventions.1.2kinstalls30Spring Boot Saga PatternSpring Boot Saga Pattern is an agent skill for solo and indie builders shipping event-driven microservices who need long-running business transactions without two-phase commit. It explains choreography-based sagas where each service publishes and subscribes to events, owns its step, and runs compensating actions when upstream steps fail—contrasted with orchestrator-led designs. The readme walks through a concrete order flow: order creation, payment, inventory reservation, and shipment preparation on the happy path, plus cancellation and cleanup when payment fails. You get implementation-oriented snippets such as an OrderEventPublisher component that emits OrderCreatedEvent through StreamBridge, which fits Spring Cloud Stream messaging stacks. Use it when you are modeling distributed consistency, designing domain events, or hardening ecommerce and API backends where partial failure is normal. It pairs well with service boundaries you already defined in validate or build planning; it does not replace idempotency keys, outbox tables, or observability—you still wire those in ship and operate. Complexity is intermediate because you need comfort with Java, messaging, and failure semantic1.2kinstalls31Unit Test Json SerializationUnit Test JSON Serialization is a Spring Boot–focused agent skill that teaches procedural patterns for verifying Jackson JSON mapping with @JsonTest and JacksonTester. Solo builders and small teams shipping JVM APIs use it when DTO shape, field renaming, or custom serializers must stay stable across releases without leaning on slow integration suites. The workflow is deliberate: annotate the test class with @JsonTest, autowire JacksonTester for the target type, assert serialization via extractingJsonPath helpers, parse JSON back into objects for deserialization checks, and validate full round-trip fidelity. Coverage spans @JsonProperty and @JsonIgnore behavior, nested structures, date and time formats, null and missing-field handling, and polymorphic deserialization—common sources of production 400s and client breakage. Allowed tools include Read, Write, Bash, Glob, and Grep so agents can locate existing tests and align new ones with project conventions. It complements broader integration testing skills rather than replacing them; reach for it when serializer logic is dense enough to deserve fast, isolated tests in the Ship phase.1.2kinstalls32Langchain4j Tool Function Calling PatternsLangChain4j Tool Function Calling Patterns documents advanced Java patterns for agents that invoke real code: memory-linked tool arguments, dynamic tool lists per request, immediate-return tools, and streaming chats that still run tools mid-turn. Solo builders shipping JVM backends or enterprise assistants use it when moving from a demo chatbot to callable functions with correct scoping and latency behavior. The snippets assume LangChain4j AiServices and standard @Tool metadata rather than hand-rolled JSON schemas. It fits the Build phase when you already have services (preferences, weather, calculators) and need the agent layer to call them safely and predictably. Pair with your API security model and tests for tool side effects; this skill teaches wiring patterns, not prompt design or deployment.1.2kinstalls33Langchain4j Rag Implementation Patternslangchain4j-rag-implementation-patterns is an agent skill for solo builders shipping JVM backends who want grounded LLM answers without guessing LangChain4j APIs. It documents practical, production-minded examples starting with a simple in-memory RAG path: create an InMemoryEmbeddingStore, configure OpenAiEmbeddingModel and OpenAiChatModel, ingest documents through EmbeddingStoreIngestor, attach EmbeddingStoreContentRetriever, and expose a small DocumentAssistant via AiServices. The skill is aimed at developers who already run Java services and need a credible baseline before adding persistence, chunking strategy, or observability. Use it while implementing document Q&A, internal knowledge bots, or agent tools backed by your own corpus. It assumes OpenAI keys in the environment and intermediate familiarity with Java builds. Prism tags it under Build backend with AI vertical focus because RAG is the bridge between your data layer and user-facing agent features.1.2kinstalls34Unit Test Utility MethodsUnit Test Utility Methods is a developer-kit agent skill that teaches you how to unit-test small, stateless Java helpers with the edge cases that actually break production. Solo builders shipping JVM backends or libraries often over-test happy paths and miss integer overflow semantics, null contracts, empty strings, Unicode capitalization, and floating-point tolerance. The skill walks through concrete JUnit examples—MathUtils and StringUtils style classes—using fluent assertions for null safety, boundary integers, large BigDecimal sums, and approximate doubles. It fits the Ship phase when you are closing gaps before a release or refactoring shared utilities agents keep regenerating. Treat it as a pattern library to paste into your test suite rather than a full test-runner integration. Extend the same mindset to collections and domain-specific boundaries once the baseline numeric and string cases are covered.1.2kinstalls35Langchain4j Spring Boot IntegrationLangChain4j Spring Boot Integration is a configuration guide skill for indie builders adding large-language-model capabilities to Java services using LangChain4j’s Spring Boot starters. It documents property-based setup in application.yml for OpenAI, Azure OpenAI, and Anthropic, covering chat models, embedding models, and streaming chat models with practical defaults for temperature, token limits, timeouts, retries, and observability flags. Solo developers shipping SaaS APIs or internal agents can standardize secrets via environment variables and align Azure deployment names with enterprise gateways. Use it while implementing backend integrations before you write custom AiServices or RAG pipelines. It complements framework docs by focusing on copy-ready YAML patterns and advanced setup paths rather than one-off REST calls.1.2kinstalls36Unit Test ParameterizedUnit Test Parameterized is an agent skill that teaches solo Java builders how to write data-driven unit tests with JUnit 5 Jupiter Params. It explains when to pick simple value sources versus CSV tables or method-backed argument factories, how to align method parameters with supplied types, and how to set display names so failures stay readable in CI logs. The skill fits shipping quality gates: boundary analysis, enum sweeps, and collapsing dozens of near-duplicate tests into one parameterized method. It assumes junit-jupiter on the classpath and walks validation through Gradle or Maven test tasks. Builders still coding features in Build can reuse the same patterns early, but the primary journey moment is pre-release test hardening in Ship.1.2kinstalls37Unit Test Security AuthorizationUnit Test Security Authorization is an agent skill for solo builders shipping Java/Spring APIs who need repeatable tests around method security. It documents how to exercise @PreAuthorize rules—admin-or-owner, hasPermission on entities, and principal id matches—with @WithMockUser and AssertJ-style exception assertions. Install it when you are hardening REST or service layers and want agents to generate consistent deny/allow cases instead of hand-waving “security is tested in prod.” The skill stays at the unit-test layer: mocked users and direct service calls, not a substitute for contract tests or penetration review. It pairs well with Spring Boot code review and ship-phase QA so authorization bugs are caught before customers hit 403/200 inconsistencies. Intermediate familiarity with Spring Security annotations is assumed.1.2kinstalls38Unit Test Exception HandlerUnit-test-exception-handler is a focused Spring Boot testing skill that shows how to exercise @ControllerAdvice classes without booting the full application. Examples use MockMvcBuilders.standaloneSetup with a slim TestController plus setControllerAdvice, Mockito for injected services like MessageService, and assertions on HTTP status and JSON message bodies. It covers localized error messages via mocked message catalogs and extends into SecurityContextHolder scenarios when handlers branch on authorization state. Solo builders shipping JVM APIs use it when global exception handling is production-critical but undertested, or when regressions slip through because handlers were only checked manually. The skill is template-driven Java rather than a generic testing framework—expect Spring Web MVC, Mockito, and JUnit-style test classes.1.2kinstalls39Unit Test Scheduled AsyncUnit Test Scheduled Async is a developer-kit agent skill that gives solo builders concrete Java examples for testing Spring Boot asynchronous and scheduled code. It documents Maven and Gradle test dependencies, shows how to exercise @Async methods returning CompletableFuture, and pairs JUnit Jupiter with Awaitility and AssertJ so agents do not default to Thread.sleep flakiness. Use it during Ship when your API or SaaS backend fires background email, notifications, or cron-style work and you need trustworthy tests agents can paste and adapt. The skill is example-forward rather than a full testing framework—ideal when you already have Spring services and want standardized async test shapes for PR-ready coverage.1.2kinstalls40Turborepo MonorepoTurborepo Monorepo is a procedural skill from the developer-kit that teaches solo and indie builders how to run production-grade CI on JavaScript monorepos managed with Turborepo and pnpm. It focuses on GitHub Actions: checkout, dependency install, then scoped tasks so agents do not waste minutes rebuilding untouched apps. The basic workflow runs lint, typecheck, tests, and build with HEAD-relative filters ideal for pull requests. A second path adds Turborepo Remote Cache so shared build artifacts speed up repeated runs when secrets are configured. The skill fits teams shipping multiple packages from one repo who want copy-paste YAML instead of ad-hoc scripts. It does not replace Turborepo task configuration in turbo.json or deployment orchestration—it standardizes the verify-and-build loop that should run before every merge.1.2kinstalls41Unit Test CachingUnit Test Caching is a developer-kit agent skill for solo builders maintaining Java Spring APIs who need trustworthy cache behavior without slow integration tests. It documents how to wire ConcurrentMapCacheManager in JUnit tests, assert that cached methods skip redundant repository calls, validate eviction after mutations, and exercise @CachePut updates. The skill targets @Cacheable, @CacheEvict, and @CachePut with SpEL key expressions and conditional parameters—common sources of subtle production bugs when TTL or Redis config differs from assumptions. Use it during Ship when you are hardening service layers before release, or in Build backend work when adding caching to hot read paths. The agent can Read and Write test classes, run Bash for Maven/Gradle, and search the codebase for annotated methods. Complexity is intermediate: you should already understand Spring caching abstractions. Deliverables are concrete test methods and fixture patterns you can paste into src/test. It complements broader integration testing but does not replace Redis contract tests when you need cluster semantics.1.2kinstalls42Unit Test Mapper ConverterUnit Test Mapper Converter is a developer-kit skill that gives solo Spring/Java builders copy-paste patterns for testing MapStruct mappers and similar converters. Wrong mapping between entities and API DTOs is a frequent source of 200 responses with corrupt payloads—especially after schema tweaks. The skill walks through instantiating generated mappers with Mappers.getMapper, building minimal domain fixtures, and asserting every mapped field with AssertJ fluent APIs, including list mappings. It assumes a standard Maven or Gradle test stack and intermediate familiarity with MapStruct code generation. Invoke during Ship when tightening coverage before a release, or in Build backend when introducing new DTO layers. The README is example-heavy rather than a multi-step ritual, so journey scope stays phase-specific on testing. Agents use it as a template generator: Read existing mappers, Write matching test classes, optionally Bash to run mvn test. It does not replace integration tests against persistence but catches static mapping mistakes cheaply. Pair with broader QA skills if you also need contract or OpenAPI validation.1.2kinstalls43Unit Test Config Propertiesunit-test-config-properties is a reference-style agent skill for solo and indie builders shipping Spring Boot APIs who need confidence that YAML and properties files actually bind to typed configuration classes. It walks through `ApplicationContextRunner` setups that inject property key-value pairs, register `@ConfigurationProperties` beans, and assert nested structures, collections, and timeouts without bootstrapping the entire application. The skill fits the Build phase when you are defining database URLs, connection pools, and replica lists in `application.yml` and want regressions caught in CI instead of at deploy time. For AEO and catalog browse, it is framed as procedural knowledge for Java backend work: not a generator, but a copy-pasteable testing pattern aligned with Spring Boot 3 conventions and AssertJ assertions.1.2kinstalls44Langchain4j Ai Services Patternslangchain4j-ai-services-patterns packages practical Java snippets for LangChain4j’s AiServices layer— the declarative way to turn an interface into an LLM-backed implementation. It walks from a minimal stateless chat example through assistants that retain a bounded message window for multi-turn support, using OpenAiChatModel configuration patterns familiar in Spring Boot and standalone JVM apps. Solo builders shipping JVM APIs or internal agents use it when they want typed service boundaries instead of raw REST calls scattered across the codebase. The skill lives on the Build/backend shelf because it is about embedding model clients, memory, and service builders into application code; it pairs naturally with env-based secrets and OpenAI-compatible endpoints.1.2kinstalls45Langchain4j Vector Stores ConfigurationLangChain4j Vector Stores Configuration is a dense API reference for solo builders shipping Java agents and RAG services who must choose an EmbeddingStore and wire it correctly. The skill opens with a nine-row comparison—In-Memory, Pinecone, Weaviate, Qdrant, Chroma, PostgreSQL, MongoDB, Neo4j, and Milvus—so you can match setup effort, performance, and scaling to indie constraints versus production scale. It documents the EmbeddingStore interface methods for single and batch adds with optional ids and embedded metadata, which is the hinge between your embedding model and retrieval filters. Use it while implementing ingestion pipelines, switching from in-memory tests to managed Pinecone or self-hosted Qdrant, or aligning with an existing Postgres pgvector deployment. It is reference material, not a full data modeling course; pair with embedding model and chunking skills for end-to-end RAG.1.1kinstalls46Langchain4j Mcp Server Patternslangchain4j-mcp-server-patterns is a template-oriented agent skill for solo builders who want a Java/Spring Boot starting point for Model Context Protocol servers using LangChain4j. Instead of translating MCP concepts from TypeScript examples, you get a concrete MCPServer bean that wires stdio transport, aggregates tool providers, resource list providers, and prompt list providers, and leaves room for external MCP clients. It fits indie teams standardizing on the JVM for backend agents, enterprise-style integrations, or shops already on Spring that need MCP parity with Node/Python stacks. Invoke it when you are defining new agent capabilities—custom tools, readable resources, or reusable prompts—not when you only need a one-off REST endpoint. The skill emphasizes builder patterns and Spring configuration so you can fork the template into domain-specific servers without re-reading MCP transport docs from scratch. Expect a scaffold you extend with your tool logic and Jackson-friendly JSON handling rather than a finished product server.1.1kinstalls47Unit Test Application EventsUnit Test Application Events is an agent skill for solo builders shipping Spring Boot services who need reliable tests around domain events. It documents how to verify ApplicationEventPublisher calls, assert listener side effects, and exercise multi-listener propagation without bootstrapping the entire application context. The workflow covers dependency setup, publisher mocks, captors for payload inspection, direct listener invocation, and practical notes for asynchronous handlers. Use it when you are hardening event-driven flows in microservices or modular monoliths and want fast, isolated tests that still match production Spring semantics. It complements broader backend work in build but lives on the testing shelf because its output is passing specs and confidence before deploy.1.1kinstalls48Langchain4j Testing StrategiesLangchain4j-testing-strategies is an advanced testing skill for developers shipping Java agents or APIs on LangChain4j. It documents how to exercise streaming chat models in tests: wire a StreamingChatModel (for example Ollama locally), implement a handler that accumulates partial responses, completes a future on onComplete, and surfaces failures on onError. Solo builders use it when a Codex or Claude agent needs concrete test scaffolding instead of guessing reactive/stream semantics. The content is pattern-oriented—copy-adapt Java snippets into your test suite as you harden RAG or chat endpoints. It assumes you already have a LangChain4j project and a runnable model endpoint for integration-style runs, and it keeps focus on Ship-phase quality gates rather than prompt design or deployment.1.1kinstalls49Aws Sdk Java V2 S3AWS SDK Java v2 S3 is an agent skill that gives solo builders copy-ready patterns for Amazon S3 using AWS SDK for Java 2.x. It documents Maven dependencies for the core S3 module, optional S3 Transfer Manager, and Netty-based async HTTP client, then shows how to construct synchronous and asynchronous S3 clients with region builders. For production-minded setups, it includes a configured synchronous client example with Apache HTTP client tuning—max connections, connection timeouts—and override configuration hooks for retry policies with exponential backoff. Use it when you are implementing file upload pipelines, user content storage, backups, or static asset workflows in a Java API or service and want consistent SDK v2 idioms instead of guessing client lifecycle or dependency sets. The skill is integration-focused procedural knowledge, not a full IAM or infrastructure-as-code guide; pair it with your account policies and bucket layout decisions.1.1kinstalls50Aws Sdk Java V2 DynamodbAWS SDK Java v2 DynamoDB is a developer-kit reference skill focused on advanced DynamoDB operations using the AWS SDK for Java 2.x Enhanced Client. It documents how to build QueryConditional objects for equality, range between sort keys, and begins-with prefixes on composite keys—patterns indie SaaS backends use for customer timelines and dated records. The skill shows filter expressions combining numeric and string predicates with expression attribute names and values, plus projection expressions that return only customerId, name, and email fields to save RCUs. Scan operations include ScanEnhancedRequest pagination guidance for tables that cannot be queried by key alone. Solo builders on JVM stacks install it so agents generate correct Java snippets instead of mixing v1 APIs or wrong key builders. It is an operations reference, not table design or IAM setup; pair with partition key design docs for greenfield schemas.1.1kinstalls51QdrantQdrant is a Backend & APIs skill aimed at solo builders shipping JVM services who need production-shaped vector search—not a toy in-memory demo. It documents a complete Spring Boot application skeleton: configuration for the Qdrant Java client, LangChain4j wiring for embeddings and the Qdrant embedding store, dedicated vector search and RAG services, and web controllers exposing search and retrieval-augmented generation flows. The examples assume you already chose Qdrant as your vector database and want copy-paste pom.xml coordinates, package layout, and class responsibilities so your coding agent does not hallucinate dependency versions or miss separation between search and RAG paths. Use it when adding semantic product search, document Q&A, or agent memory backed by Qdrant in a Java stack. Complexity is intermediate because you must run Qdrant (local or cloud), understand embedding models, and align LangChain4j versions with the client. It complements generic LLM prompt skills by covering the persistence and API surface that actually serves vectors at scale.1.1kinstalls52Aws Rds Spring Boot IntegrationAWS RDS Spring Boot Integration is an agent skill that walks solo builders through advanced Amazon Aurora configuration inside a Spring Boot service, especially when read traffic dominates writes. It documents how to declare distinct writer and reader DataSource beans, bind them via configuration properties, and wire separate LocalContainerEntityManagerFactoryBean instances so JPA repositories can target the correct cluster endpoint. That split is the standard way indie SaaS backends scale Postgres-compatible Aurora without bolting on ad-hoc connection hacks. Use it while you are still shaping persistence layer architecture—before you bake single-datasource assumptions into every repository. The snippets assume a conventional com.example.domain package layout and expect you to align IAM, VPC, and Secrets Manager outside the skill, but the Spring wiring itself is copy-adapt ready for production-minded APIs.1.1kinstalls53Aws Sdk Java V2 Lambdaaws-sdk-java-v2-lambda teaches solo builders and small teams how to stand up AWS Lambda clients with SDK for Java v2 instead of copying outdated v1 samples. You get Maven coordinates, Region-scoped builders, and a choice between blocking LambdaClient and non-blocking LambdaAsyncClient for event-driven APIs. Custom Apache HTTP timeouts address cold starts and long-running invocations that otherwise fail silently with default sockets. Credentials examples use StaticCredentialsProvider for development while reminding you to prefer instance roles or default credential chains in production. Spring Boot notes help embed invoke calls inside existing JVM services. Reach for this skill when scaffolding a new Lambda caller, debugging timeout errors, or standardizing client configuration across microservices during the build phase.1.1kinstalls54Aws Sdk Java V2 Bedrockaws-sdk-java-v2-bedrock is a developer-kit skill for solo builders and small teams who ship JVM backends and want copy-paste-correct Amazon Bedrock Runtime calls instead of guessing JSON shapes per model. It focuses on AWS SDK for Java v2 BedrockRuntimeClient usage, showing how to construct InvokeModel requests, attach UTF-8 JSON bodies, and parse structured responses for Anthropic Claude variants—with separate tuning notes for Sonnet versus the faster Haiku profile. The readme positions additional foundation models under an advanced patterns section so you can branch from the same client setup. Reach for it when you are embedding inference in a Spring or plain Java service, prototyping agent backends on AWS, or standardizing one integration path before you add streaming or guardrails. It assumes you already have AWS credentials and model access configured in your account.1.1kinstalls55Aws Sdk Java V2 Coreaws-sdk-java-v2-core is a reference-oriented agent skill for solo builders shipping JVM backends on AWS who repeatedly recreate the same ClientBuilder boilerplate with slightly wrong timeout or retry settings. AWS SDK 2.x moved to fluent builders and explicit ClientOverrideConfiguration, which is safer than v1 magic but easy to misconfigure under load. The skill summarizes core types—AwsClient, SdkClient, builders, override configuration—and gives copy-ready patterns for region selection, credentials providers, HTTP client injection, and metrics publishers. Use it during Build when you add a new service client, harden timeouts for Lambda callers, or standardize configuration across microservices in a monorepo. It is not a full IAM or infrastructure-as-code guide; it keeps agents aligned with official v2 construction idioms so you spend less time debugging Signature V4 errors that are actually thirty-second global timeouts or missing attempt limits.1.1kinstalls56Aws Sdk Java V2 Kmsaws-sdk-java-v2-kms is a narrow integration skill from Giuseppe Trisciuoglio’s developer-kit that guides your coding agent through AWS Key Management Service operations using AWS SDK for Java version 2. Solo builders shipping JVM APIs or SaaS backends use it when they need envelope encryption, data-key generation, or CMK-backed encrypt and decrypt without spelunking AWS docs alone. The skill sits in the Build phase because it produces application code and configuration patterns, not production runbooks. Expect agent-assisted snippets and conventions aligned with the v2 client builder model, grant-aware calls where relevant, and reminders to scope IAM least privilege. You still need an AWS account, a KMS key policy that matches your tenancy model, and local JDK plus build tooling. After implementation, you validate in Ship (security review) and Operate (key rotation and CloudTrail). Prism lists installs from skills.sh separately; this tag layer does not assert download counts.1.1kinstalls57Aws Sdk Java V2 Secrets ManagerThis developer-kit skill packages AWS Secrets Manager guidance for Java teams on SDK v2, with a Spring-oriented configuration template using SecretsManagerClient and the AWS secrets caching library (SecretCache). Solo builders shipping JVM APIs or SaaS backends use it when hardcoding database passwords or API keys is no longer acceptable and they need a repeatable pattern: region-scoped client, credentials provider hook, and bounded in-memory cache TTL to cut API calls during steady-state requests. The readme blends copy-paste configuration stubs with service overview text, so the agent can scaffold beans and explain retrieve/update semantics without guessing SDK v2 class names. It sits at intermediate complexity—assume you already run Spring and have an AWS account. Pair with IAM least-privilege policies and rotation runbooks in Ship and Operate when secrets change in production.1.1kinstalls58Aws Sdk Java V2 MessagingAWS SDK Java v2 Messaging is an agent skill that condenses official Amazon SQS and SNS guidance for Java 2.x developers into invoke-ready reference material. Solo builders use it when standing up producers, consumers, fan-out topics, or batch workers without re-reading entire AWS guides. It catalogs core API operations—queue lifecycle, batched sends, receives, deletes—and advanced concerns like long polling waitTimeSeconds, visibility timeouts, dead-letter queues, FIFO guarantees, and S3-backed large payloads beyond 256KB. Class-level anchors such as SqsClient and service model packages help agents generate compilable imports instead of pseudo-code. The skill fits microservices, async job runners, and event notifications in JVM backends integrated through Prism’s development track. It is reference-heavy rather than a full infrastructure-as-code tutorial; pair it with your IAM and environment secrets practices. Intermediate complexity assumes comfort with AWS accounts and async messaging concepts.1.1kinstalls59RagThe rag skill documents a complete Retrieval-Augmented Generation pipeline in Java using LangChain4j: load documents, parse and split text, embed segments, ingest into a vector store, and query with optional metadata filters. Solo builders shipping JVM-based agents, internal copilots, or SaaS APIs use it when they need a concrete reference instead of piecing together LangChain4j APIs from scattered docs. It fits the Build phase when you are connecting your backend to embedding providers and a hosted or self-hosted vector database. You choose among in-memory stores for prototypes and Pinecone, Chroma, or Qdrant for production-shaped deployments. The pattern emphasizes composable stores, ingestors, and filters so retrieval behavior stays explicit and testable before you add generation and guardrails in ship and operate.1.1kinstalls60Aws Sdk Java V2 Rdsaws-sdk-java-v2-rds is an agent skill that teaches Amazon RDS management with the AWS SDK for Java 2.x for solo builders shipping JVM backends on AWS. It walks through adding RDS SDK dependencies and database drivers, constructing a regional RdsClient with credentials, provisioning and modifying DB instances, hardening networking with security groups and encryption, configuring backup windows and retention, polling instance health, and taking snapshots ahead of risky changes including failover awareness. Use it when you are creating or deleting instances, tuning parameter groups, enabling Multi-AZ, or wiring serverless compute to a relational store and want consistent SDK v2 calls instead of ad-hoc Stack Overflow snippets. It matters because misconfigured backups, security, or client lifecycle create expensive outages; the skill turns scattered AWS docs into an ordered integration checklist your coding agent can follow in-repo.1.1kinstalls61Tailwind Design SystemTailwind Design System is an agent skill for solo and indie builders who already use shadcn/ui and Tailwind but want a thin design-system layer on top. Instead of importing raw shadcn components everywhere with inconsistent className sprawl, you follow patterns that wrap primitives—Button and Text are documented—with stable variant and size enums, explicit maps to the underlying library, and shared utilities like cn(). That keeps tokens and naming consistent as you ship dashboards, marketing pages, or SaaS shells with Claude Code, Cursor, or similar agents. Use it during the Build phase when you are structuring components/ds (or equivalent) and need copy-paste-ready TSX that enforces your API without re-architecting the whole stack. It matters because agents otherwise hallucinate one-off Tailwind classes; wrappers give them a bounded vocabulary that matches your product design language.1.1kinstalls62Nextjs App Routernextjs-app-router is a reference agent skill from the developer-kit that walks solo and indie builders through Next.js App Router fundamentals: when routes run as Server Components by default, when to opt into Client Components, and how to compose both without leaking secrets or bloating JavaScript. It is aimed at builders shipping marketing sites, dashboards, and SaaS frontends who want Claude Code, Cursor, or Codex to generate layouts that match modern Next.js conventions instead of Pages Router habits. Use it while scaffolding app/, choosing fetch vs client state, and splitting interactive widgets from server-rendered shells. The skill matters because wrong boundaries cause hydration bugs, exposed credentials, and unnecessary client bundles—common pitfalls when agents freestyle React. Pair it with backend and auth skills once pages need protected data; treat it as the frontend spine for any Next-based build.1.1kinstalls63Nx Monoreponx-monorepo is a reference-oriented agent skill for solo and indie builders running Nx workspaces. It documents how to wire task orchestration so builds, tests, and lint run in the right order across apps and libraries, including cross-project dependsOn and sensible defaults in nx.json. Caching coverage explains local Nx cache behavior and when to bypass or reset, plus optional Azure and Nx Cloud remote cache setup with workspace IDs and activation keys. For shipping, it emphasizes affected commands and GitHub Actions SHA helpers so CI only executes targets touched by a changeset. Use it when you are growing past a single package, tuning CI minutes, or debugging why a target did not run or did not cache. It is procedural knowledge for Nx—not a scaffold generator—so you still own your repo layout and pipeline YAML.1.1kinstalls64Typescript Security ReviewTypescript-security-review is an agent skill that walks through common TypeScript and Node.js vulnerability patterns and how to fix them in context. Solo builders shipping APIs, SaaS backends, or CLIs can invoke it during implementation or before release so the agent flags risky query construction, deserialization assumptions, shell calls, and regex hotspots instead of relying on memory alone. The skill is pattern-oriented: each section contrasts a vulnerable example with a hardened alternative, which suits incremental refactors and PR review. It fits indie teams who do not run a dedicated appsec program but still need OWASP-aligned habits on Express, Nest, or plain Node services. Use it when adding user-controlled strings to databases, shells, or heavy regex validators, or when onboarding an agent to your repo’s security baseline.1kinstalls65Nextjs Data FetchingNext.js Data Fetching is a developer-kit agent skill focused on caching and revalidation in the App Router. It teaches when to use time-based ISR with next.revalidate, when to trigger on-demand updates through revalidateTag or revalidatePath after writes, and how to tag fetch calls so multiple routes invalidate together. It also covers opting out of caching when data must always be fresh. Solo builders shipping marketing sites, dashboards, or SaaS on Next.js get copy-paste patterns that keep server components fast without serving stale content after mutations. The skill reduces agent mistakes like random revalidate seconds, tag sprawl, or forgetting to wire POST handlers to invalidation. Use it while implementing pages and API routes, not as a substitute for load testing or CDN configuration at ship time.1kinstalls66Aws Lambda Typescript IntegrationAWS Lambda TypeScript Integration is an agent skill that teaches solo builders how to create and deploy serverless APIs in TypeScript on AWS with deliberate cold-start and bundle-size trade-offs. It contrasts a NestJS framework path—dependency injection, modular structure, and larger artifacts around 100KB or more—with a raw TypeScript path that keeps handlers lean under roughly 50KB for maximum control. Both approaches are documented for API Gateway and ALB front ends, so you can match your ingress to existing infrastructure. Use it when you are starting a new function, tuning startup latency, choosing framework vs minimal handlers, or wiring CI/CD for TypeScript Lambdas. For indie builders shipping APIs without a platform team, the skill turns ambiguous “serverless in TS” chats into repeatable integration patterns instead of one-off deploy scripts.1kinstalls67Aws Lambda Python IntegrationAWS Lambda Python Integration documents how solo builders ship serverless HTTP APIs using AWS Chalice. The skill explains what Chalice adds on top of raw Lambda—Flask-like routes, generated IAM policies, CORS defaults, a local dev server, and straightforward API Gateway deployment. Installation steps cover pip, version checks, and new-project scaffolding. You get a canonical directory tree separating app entrypoint, stage config, deploy artifacts, shared chalicelib services, and tests. Minimal and multi-method route examples show GET and POST handlers with JSON bodies via current_request. Use it when you want your coding agent to follow Chalice conventions instead of mixing SAM, Serverless Framework, and hand-rolled handlers. It assumes Python literacy and an AWS account; it does not replace production observability, auth design, or load testing—that comes later in Ship and Operate.1kinstalls68Nextjs Authenticationnextjs-authentication is an agent skill that walks solo and indie builders through a complete Auth.js 5 setup on Next.js App Router. It targets founders shipping SaaS or API-backed products who need Google or credential providers, role-aware sessions, and protected routes without piecing together scattered docs. The guide specifies installation commands, the canonical project structure from auth configuration through API handlers and UI components, and TypeScript extensions so agents generate type-safe session and JWT shapes. You use it when scaffolding login, dashboard gating, or OAuth for a greenfield or half-built Next app in the build phase. It matters because misconfigured auth blocks shipping and creates security debt; a single procedural reference keeps the agent aligned with Auth.js 5 conventions for middleware, providers, and server-side session access.1kinstalls69Nextjs DeploymentNext.js Deployment is a platform-focused agent skill from the Developer Kit that helps solo builders ship Next.js applications to production hosts without guessing JSON shapes or env conventions. It documents Vercel as the native path—framework detection, build and install commands, regional deployment, security headers like X-Frame-Options, and API rewrites—plus CLI flows for adding DATABASE_URL and public API URLs. For teams avoiding Vercel lock-in, it includes AWS Elastic Container Service on Fargate with a concrete task definition template covering CPU, memory, awsvpc networking, and container port mappings. Preview environments receive explicit treatment so PRs get automatic deploys with preview-scoped secrets. The skill fits indie SaaS and API-backed Next apps that already build locally and need a copy-pasteable hosting contract. It does not replace infrastructure-as-code for entire orgs, but it compresses the first production deploy and the security-header baseline into agent-actionable snippets a single founder can apply in one session.1kinstalls70Better Authbetter-auth is an agent skill from the developer-kit that helps solo builders stand up Better Auth with the environment variables and provider hooks you actually need in a real deploy, not a toy login demo. The documented surface centers on PostgreSQL as the database backbone, a minimum-length auth secret, canonical app URLs for server and client, and a wide OAuth matrix so you can enable social sign-in incrementally. Email-based flows are covered via SMTP host, port, credentials, and from-address branding, which matters for magic links and verification in production-minded SaaS. If you run sessions through Redis, the kit points you at the relevant configuration rather than leaving session scale as an afterthought. Invoke it when you are integrating auth into a Next-style or full-stack TypeScript app and want the agent to scaffold secrets and provider env blocks consistently while you fill in real client IDs from each vendor console.998installs71Nestjs Drizzle Crud Generatornestjs-drizzle-crud-generator accelerates database-backed NestJS features for solo builders who want type-safe CRUD without hand-copying boilerplate across entities. You define the entity name and a JSON field list with required vs optional defaults, then execute the bundled Python generator to emit a feature module aligned with Drizzle ORM and Zod validation conventions from the developer-kit. The output spans controllers, services, DTOs, schema definitions, and unit tests so agents can wire endpoints immediately and iterate on business rules instead of folder ceremony. Use when prompts ask for a user module, product CRUD, or new entity with endpoints in an existing Nest monorepo. Prerequisites include a target output path and clarity on field types via the kit's field-types reference.997installs72Nextjs Code ReviewNextjs-code-review equips agents and solo builders to judge Next.js App Router projects against concrete segment patterns instead of generic React lint rules. It documents how layouts should wrap persistent navigation, how loading.tsx supplies instant Suspense fallbacks, how error.tsx must be a client component with reset affordances, and how not-found.tsx localizes missing resources inside dynamic routes. The skill fits a pre-merge or pre-deploy review when a freelancer ships dashboard-style SaaS on Next.js and needs consistent UX resilience. It is pattern-reference depth from the developer-kit family, so the agent applies it while reading an existing repo tree rather than generating a greenfield template from scratch.992installs73Nestjs Code ReviewNestJS Anti-Patterns is an agent skill for solo and indie builders shipping NestJS APIs who want review guidance grounded in concrete TypeScript examples rather than generic lint rules. It walks through controller mistakes such as embedding registration, hashing, JWT issuance, and email sends in route handlers, and shows the thin-controller plus service-layer fix. It also flags controllers that inject TypeORM repositories directly instead of domain services, and service-layer smells like monolithic god services that mix unrelated concerns. Use it while you are still building features or during pre-merge review in Ship so agents refactor toward single responsibility, testable services, and consistent Nest patterns. It complements automated tests by encoding architectural expectations your agent can apply file-by-file without inventing a separate checklist each time.991installs74React Code ReviewReact Code Review is an agent skill from the Developer Kit that packages React accessibility checklist guidance and ARIA-oriented patterns for solo builders shipping web UIs with Claude Code, Cursor, or Codex. It steers reviewers to pick native semantic elements before adding ARIA, separate actions (buttons) from navigation (links), and ensure keyboard operability on every interactive control. The included snippets show how to implement accessible toggles and how to avoid common anti-patterns such as clickable divs or router pushes hidden inside button elements. Use it while you are polishing components during Build or during formal review in Ship so accessibility debt does not accumulate across pages. The focus stays on frontend markup and interaction contracts rather than CI wiring or Lighthouse automation alone, which makes it a practical companion when you want consistent, explainable feedback your agent can apply file by file.973installs75Aws Lambda Java Integrationaws-lambda-java-integration is a Micronaut-focused reference skill for building AWS Lambda functions on Java 21. Indie builders shipping API backends or event-driven workers use it when they want framework-native dependency injection and a documented path from Gradle setup through handler code, cold-start tuning, and deploy configuration. The guide is structured as five sections: project setup with Shadow fat JAR and Micronaut AWS function modules, handler implementation patterns for API proxy and custom runtime, cold start optimization guidance, DI usage inside the Lambda lifecycle, and deployment configuration notes. Dependencies pin common AWS Lambda Java libraries and optional SDK clients for DynamoDB and S3, with JUnit 5 and Mockito for tests. It suits Build-phase backend work for teams already committed to Micronaut rather than plain handlers or other JVM frameworks.968installs76Nestjs Best Practicesnestjs-best-practices packages opinionated guidance grounded in the official NestJS docs for builders shipping typed HTTP APIs. Use it when carving feature modules, scoping providers, adding global or scoped exception filters, hardening request DTOs with class-validator, or embedding Drizzle as the persistence layer without leaking ORM details across module graphs. The skill emphasizes encapsulation—controllers, services, and repositories colocated per domain—and a SharedModule for logging, configuration, and caching cross-cuts. It is aimed at solo and indie developers who want an agent to enforce structure during greenfield setup or when reviewing an inherited codebase for anti-patterns. Reference files such as architecture module boundary notes deepen enforcement beyond the SKILL.md overview. Treat it as a build-time backend companion rather than a deployment or marketing workflow.968installs77Aws Lambda Php Integrationaws-lambda-php-integration collects best practices for running PHP on AWS Lambda, aimed at solo builders using Bref with either slim handlers or Symfony. It translates cold-start and timeout realities into concrete memory defaults, keeps deployment packages under Lambda’s size ceiling through minimal Composer dependencies, and shows how to return API Gateway–friendly status codes instead of uncaught stack traces. Structured logging with request IDs helps you debug in Grow and Operate without bolting on a separate APM on day one. The skill is reference prose—not a deploy script—so you still need your own IaC or Bref config, but agents can enforce these patterns during implementation reviews. Intermediate complexity assumes you already chose Lambda over long-lived VPS hosting.960installs78Zod Validation Utilitieszod-validation-utilities documents advanced validation patterns on Zod v4 for solo builders who outgrew simple object schemas. Install or invoke it when API payloads, domain events, or hierarchical config need discriminated unions with literals, recursive structures, or validated maps and sets—cases where manual TypeScript narrowing drifts from runtime checks. The skill shows concrete schemas such as multi-variant event unions with coerced dates and emails, lazy recursive tree nodes with strict objects, and record/map patterns suitable for SaaS backends and internal CLIs. It sits in Build backend work alongside route handlers, workers, and shared packages where one source of truth for parse and infer prevents silent bad data. You still own error messaging, OpenAPI alignment, and test coverage; this skill accelerates schema design so agents generate consistent Zod v4 instead of one-off validators.943installs79Github Issue Workflowgithub-issue-workflow encodes how a solo builder should turn a GitHub issue into a mergeable fix without thrash. It is not a single shell command; it is procedural knowledge for agents and humans: restate the issue, use structured confirmation (including AskUserQuestion-style gates), surface ambiguities in an early requirements phase, and only then implement. The skill pushes against scope creep—no drive-by refactors, no features outside the ticket—and favors concrete questions (client vs server validation) over open-ended “what do you want?” prompts. Branch naming consistency keeps release and support readable when you are the only engineer. Expect to reuse the same principles when triaging bugs in Build, tightening PRs in Ship, and clarifying grow-phase fixes that started as user-reported issues.935installs80Notebooklmnotebooklm is a developer-kit agent skill that teaches agents to use Google NotebookLM through the notebooklm-mcp-cli (`nlm`) for retrieval-augmented workflows against notebooks you curate. Solo builders can offload bulky PRDs, API docs, and research corpora into NotebookLM, then ask the agent to query, summarize, or cross-check facts without pasting entire wikis into chat. The skill covers when to trigger on terms like notebooklm or research notebook, which Bash/read/write operations are in scope, and how to manage sources and generated studio artifacts such as podcasts or reports. It is especially useful when documentation already lives in notebooks and you want consistent, context-grounded answers during implementation, validation research, or content planning.933installs81Spring Boot Project CreatorSpring Boot Project Creator is an agent skill that bootstraps new Java backends from scratch using Spring Initializr. Solo builders and small teams use it when they want a standardized Spring Boot 3.x or 4.x project without hand-rolling Gradle/Maven layout, package conventions, or local infra. The workflow guides parameter selection, picks Domain-Driven Design versus layered architecture, attaches common dependencies such as JPA and SpringDoc OpenAPI, and produces Docker Compose services for PostgreSQL, Redis, and MongoDB so development matches production-shaped data layers. It fits agent sessions triggered by phrases like “create spring boot project” or “scaffold spring boot microservice,” and ends with a structure you can open in an IDE and build immediately. Permissions include Bash for downloads and file writes for the generated tree.930installs82Docs UpdaterUniversal Documentation Updater is an agent skill for solo and indie builders who ship skills, plugins, or multi-package repos and cannot keep CHANGELOG and reference files manually aligned with every commit. After you add a feature or touch SKILL.md trees, you invoke it with a plain request to update docs; it resolves the latest release tag, compares that baseline to your working branch, counts commits and changed paths, and drafts structured Unreleased changelog bullets grouped by what shipped. The same flow supports release preparation so nothing user-facing is stale when you tag, plus ongoing documentation sync for day-to-day merges. It is aimed at maintainer workflows in developer-kit-style layouts rather than greenfield app scaffolding, and it pairs naturally with git-based release discipline and semantic versioning habits.923installs83Graalvm Native Imagegraalvm-native-image is an agent skill that walks solo and indie builders through Gradle-based GraalVM native image builds using the official Native Build Tools plugin. It is aimed at developers shipping JVM backends, CLIs, or Spring Boot services who want sub-second startup and smaller deploy artifacts without maintaining a separate build pipeline from their existing Gradle project. The skill organizes guidance into plugin setup for Kotlin and Groovy DSL, configuration options for binaries and launchers, Spring Boot integration, running tests in native mode, and coordinating multi-module Gradle trees. Readers get copy-ready snippets for graalvmNative blocks, Java 21 GraalVM toolchains, and common native-image flags before running nativeCompile. Use it when you are past prototype and need repeatable native binaries for containers, edge, or cost-sensitive hosting—not when you only need a standard JAR dev loop.911installs84Dynamodb Toolbox PatternsDynamoDB Toolbox Patterns is a reference-oriented agent skill that routes builders to DynamoDB Toolbox v2 documentation for tables, entities, schemas, and commands. It aggregates Context7 LLM reference material and GitHub doc paths for getting started, Table.build(), query and scan actions, schema modifiers, and GetItemCommand—so an agent can implement KV stores, typed entities, and consistent parse/build pipelines. Solo founders shipping AWS-backed APIs or SaaS backends use it when they have chosen DynamoDB and want toolbox-native modeling rather than ad-hoc DocumentClient calls. The skill does not deploy tables or write IaC; it shortens the path from empty repo to correct toolbox abstractions during backend build.875installs85GeminiGemini is a command-reference agent skill for solo builders who already use Claude Code, Cursor, or Codex and want a second model on tap via the Gemini CLI. It explains how to run one-shot English prompts with `gemini -p`, resume prior work with `-r`, and pick Flash for fast scans, JSON extraction, or scaffolding versus Pro when you need slower, deeper passes. The readme emphasizes plan-mode approval for sensitive repo work and structured JSON for scripts that feed your main agent. It does not replace your primary IDE agent; it standardizes how you spawn Gemini as a subprocess for architecture reviews, vulnerability triage, and iterative module focus without opening an interactive shell every time.875installs86Copilot CliCopilot CLI is a reference-backed agent skill for handing work to GitHub Copilot’s CLI in scripted, non-interactive sessions. Solo builders use it when their primary agent (Claude Code, Cursor, Codex, or similar) should spawn Copilot with a clear English prompt, an optional fixed model, and controlled tool permissions instead of an open-ended interactive shell. The skill documents core invocation patterns, permission tiers from scoped `shell(git)` through full `--yolo`, and session lifecycle features including resume and markdown export of conversations. It fits multi-agent setups where you want Copilot for a bounded subtask while keeping the parent agent accountable for reviewing diffs before merge. Complexity is intermediate: you must understand CLI flags and security tradeoffs, but you do not need to maintain a custom Copilot API integration yourself.871installs87Sonarqube McpSonarqube-mcp is a procedural skill for solo and indie builders who wire SonarQube into agent-assisted pull request review. It describes how to call SonarQube MCP tools after CI analyzes a PR: read the quality gate, drill into failing conditions, search project issues scoped to the PR, and present a categorized summary developers can act on. The workflow emphasizes security issues first, then reliability bugs, then maintainability smells, and includes a re-check step after fixes land. It fits teams shipping services or APIs where merge discipline matters more than guessing from diff noise alone. Use it when your repo already reports to SonarQube and you want your coding agent to follow the same gate semantics your pipeline enforces, instead of generic “looks fine” reviews.870installs88Memory Md Managementmemory-md-management encodes a quality rubric for agent memory files—typically MEMORY.md or equivalent persistent notes your Claude Code, Cursor, or Codex session reloads each run. It breaks evaluation into five weighted areas: Commands and Workflows (up to 20 points) for build, test, lint, deploy, and everyday ops; Architecture Clarity (20) for directories, module relationships, entry points, and data flow; Non-Obvious Patterns (15) for gotchas, edge cases, and intentional quirks; Conciseness (15) to reject restated comments and fluff; and Currency (15) so guidance matches the tree today. Solo builders use the skill whenever memory drifts after refactors or when onboarding a new agent to an old repo—the scorer gives explicit partial-credit bands so you know what to fix next. It is methodology, not a formatter: you still edit the markdown, but the criteria mirror what actually reduces mistaken commands and wrong-file edits in production agent loops across Idea research notes through Operate runbooks.838installs89Wiremock Standalone DockerWireMock Standalone Docker packages a ready Compose stack for solo builders who need a local HTTP mock instead of flaky sandbox APIs. It runs WireMock 3.5.2 with global response templating, mounts a ./wiremock volume for mappings, and documents healthchecks plus example JSON stubs—including forbidden responses, regex URL patterns with Handlebars-style variables, and intentionally broken JSON for parser tests. You can point an app at API_BASE_URL=http://wiremock:8080 on the bundled bridge network, matching a typical microservice or mobile client integration loop. Complexity is beginner-friendly if you already use Docker; the skill is templates and compose config rather than a test runner. Use during Ship testing when backends are unfinished or paid APIs are rate-limited, not when you only need in-process mocks inside a single unit test file.833installs90CodexCodex is a journey-wide reference skill from developer-kit that teaches solo builders how to hand off implementation and review tasks to the Codex CLI without re-learning flags each session. It catalogs interactive vs non-interactive entry points, resume and fork flows, model selection for depth versus iteration speed, and approval policies from conservative untrusted baselines through on-request development defaults. You use it whenever your primary agent (Claude Code, Cursor, or similar) should spawn Codex for a bounded English prompt—refactors, test generation, architecture sketches, or review passes—while keeping session continuity. The skill is procedural documentation rather than a code generator itself; it reduces delegation mistakes and aligns multi-agent habits across validate spikes, build refactors, ship reviews, and operate fixes.828installs91Knowledge Graphknowledge-graph is a developer-kit reference skill that codifies how agents should behave when the project knowledge graph file is missing or broken. Solo builders using spec-to-tasks workflows depend on a single JSON source of truth for controllers, services, APIs, and integration points; this skill prevents silent data loss or bogus merges. On a missing file, agents seed a documented empty graph and continue—appropriate for the first feature pass or a new spec id. On invalid JSON, agents stop with a clear corruption message and offer recreation from codebase analysis instead of patching bytes blindly. The content spans architectural patterns, technology stack fields, and internal versus external API lists, so downstream task generation stays consistent. Treat it as guardrails for any agent pass that reads or writes KG state during Build planning and later Operate-style iteration when specs refresh.821installs92Adr DraftingADR Drafting is an agent skill for solo builders who need durable, searchable records of technical choices without a heavyweight architecture review process. It walks you through writing Architecture Decision Records in markdown: a clear title, current status, the problem context, the decision taken, and honest consequences including migration and ops costs. The bundled examples cover adopting PostgreSQL over SQLite and introducing event-driven order processing, so you can mirror tone and depth for your own repo. Use it when you are about to change databases, messaging, auth, or deployment patterns and want a single source of truth under docs/architecture/adr instead of scattered comments in PRs. It fits indie SaaS and API backends where one person makes the call and still needs to explain it to collaborators or coding agents months later.794installs93Aws CdkAWS CDK Core Concepts is a reference skill for solo and indie builders who ship on AWS and want typed infrastructure instead of YAML sprawl. It walks through how an App becomes a construct tree, how synthesis produces CloudFormation templates and assets under `cdk.out/`, and how deploy ties back to real account and region environments. You use it while scaffolding stacks, wiring Lambda or container assets, or debugging why synth or deploy fails. The material maps cleanly to agent-assisted coding in Claude Code or Cursor: the agent can apply construct patterns, env binding, lazy tokens, and Aspects when you extend or split stacks. It does not replace AWS account setup or security review—it accelerates correct CDK structure so you can iterate from build through ship and operate without losing the mental model of what CloudFormation will actually receive.781installs94LearnLearn is an orchestrator skill for solo builders and small teams who want Claude Code to stop guessing project style. It reads the codebase with allowed tools, delegates intensive pattern extraction to a learn-analyst sub-agent, then surfaces ranked conventions for user approval before writing rule files under `.claude/rules/`. That makes it valuable when onboarding to a legacy repo, after a big refactor, or whenever agents keep violating unstated team norms. The two-agent split keeps analysis prompts focused while the orchestrator handles AskUserQuestion flows and persistence. It is not a linter replacement—it encodes human-readable rules agents should follow on future tasks. Expect intermediate setup: you need a real project tree, willingness to review proposed rules, and Claude Code-compatible rule paths. Best paired with ongoing Build and Operate work where consistency compounds over time.736installs95Specs Code Cleanupspecs-code-cleanup is a Developer Kit agent skill for solo builders who want a disciplined final pass once review approves a change. It focuses on cosmetic and hygiene work: delete debug logging, scratch comments, unreachable code, normalize imports, and run the right formatter or linter for Java, TypeScript, or Python stacks listed in its reference table. The workflow expects Bash, Grep, and edit tools so agents can search repositories with concrete patterns rather than eyeballing diffs. That separation matters for indies moving fast with Claude Code or Cursor—logic fixes belong in review or debugging skills; this one prevents embarrassing console.log leaks and inconsistent style from landing on main. Invoke when asked to clean up, polish, finalize, tidy up, or remove technical debt after review, not when behavior is still wrong. Deliverables are merge-ready files with imports ordered per project conventions and formatters applied, keeping your Ship lane fast without reopening design debates.731installs96Ralph LoopRalph Loop is an agent skill for spec-driven delivery: you point it at a feature spec folder and it walks a numbered task list with implement, review, and sync stages for each TASK markdown file. Solo builders use it when a plan already exists as specs and tasks but chat-based coding drifts off the checklist or skips review before moving on. The skill keeps loop state—current task index, per-step completion, and dependencies—so the agent finishes TASK-001 before TASK-002 and does not leave review or sync hanging. It fits indie teams shipping features from docs/specs layouts who want repeatable agent sessions instead of one-shot prompts. Pair it with planning skills that produce the spec and tasks files first; Ralph Loop is the execution rhythm on top of that structure.710installs97Qwen CoderQwen Coder is a reference skill for solo builders who want their primary coding agent to offload work to the Qwen CLI without reinventing flags every time. It explains interactive versus non-interactive prompts, how to continue or resume sessions by ID, and when to pick Qwen2.5-Coder versus QwQ for speed versus depth. Examples cover REST endpoints with tests, markdown documentation, and JSON-shaped outputs for pipelines. Use it while you are building backends, refactors, or agent automation where a second model run is cheaper or faster than monolithic chat. It does not replace your repo’s architecture decisions—it standardizes the delegation commands so scripts and skills stay consistent across Cursor, Claude Code, and Codex-style harnesses.707installs98Task Quality KpiTask Quality KPI is an agent skill for solo builders running file-based task workflows in developer-kit style repos. A hook automatically runs when TASK markdown files are saved, executes task-kpi-analyzer.py, and writes TASK-XXX--kpi.json. The skill teaches agents to consume those metrics—understand each KPI, interpret scores on a 0–10 scale, and choose iterate versus approve with data instead of gut feel. That fits Prism’s Ship and Build journey: you still write tasks during Build PM work, but the payoff is objective review before you ship or close a loop. Intermediate complexity assumes TASK-*.md naming, hook setup, and willingness to trust automation over handwritten review_status. Use it whenever evaluation ambiguity slows your agent loop; skip it if you do not use TASK files or have no hook emitting KPI JSON.532installs