giuseppe-trisciuoglio/developer-kit▌

Utility-first CSS framework patterns for responsive, component-based styling with Tailwind v4.1+. \n \n Covers responsive design with mobile-first breakpoints, flexbox/grid layouts, spacing scales, typography, colors, and interactive states \n Includes CSS-first configuration via @theme directive, custom utilities, and container queries for modern styling workflows \n Provides 10+ component patterns (cards, navigation, forms, modals) with accessibility guidelines and dark mode support \n Support

This skill provides structured, comprehensive code review for React applications. It evaluates code against React 19 best practices, component architecture patterns, hook usage, accessibility standards, and production-readiness criteria. The review produces actionable findings categorized by severity (Critical, Warning, Suggestion) with concrete code examples for improvements.

Evaluates Next.js App Router code against best practices for Server Components, Client Components, Server Actions, caching strategies, and production-readiness criteria. Produces actionable findings categorized by severity with concrete code examples. Delegates to typescript-software-architect-review agent for architectural analysis.

Grounded in the Official NestJS Documentation, this skill enforces modular architecture, dependency injection scoping, exception filters, DTO validation with class-validator, and Drizzle ORM integration patterns.

Expert guide for building type-safe database applications with Drizzle ORM. Covers schema definition, relations, queries, transactions, and migrations for all supported databases.

Complete guide to building accessible React components with shadcn/ui, Radix UI, and Tailwind CSS. \n \n Install and configure components via CLI ( npx shadcn@latest add ), then customize directly in your project since you own the code \n Covers 10+ core components: buttons, inputs, forms with Zod validation, cards, dialogs, dropdowns, sheets, tables, toasts, and charts built on Recharts \n Full Next.js App Router integration with Server Components, form handling, and metadata support; all compo

Comprehensive Next.js performance optimization covering Core Web Vitals, modern React patterns, and production-grade techniques. \n \n Covers Core Web Vitals optimization (LCP, INP, CLS), image/font optimization with next/image and next/font , and caching strategies using unstable_cache and revalidateTag \n Guides conversion of Client Components to Server Components, implementation of Suspense streaming for progressive loading, and bundle size reduction through code splitting \n Includes Next.js

Expert skill for building high-performance native executables from Java applications using GraalVM Native Image, dramatically reducing startup time and memory consumption.

Provides comprehensive CLAUDE.md file management capabilities including auditing, quality assessment, and targeted improvements. This skill ensures Claude Code has optimal project context by maintaining high-quality documentation files.

Persistence layer patterns for Spring Data JPA repositories, entities, queries, and advanced features. \n \n Create repository interfaces extending JpaRepository with derived queries, custom @Query methods, and automatic CRUD operations \n Configure entity relationships (one-to-one, one-to-many, many-to-many) with appropriate cascade types and fetch strategies \n Implement pagination, sorting, database auditing with timestamps and user tracking, and transaction management \n Optimize performance

Security review for TypeScript/Node.js applications. Evaluates code against OWASP Top 10, framework-specific patterns, and production-readiness criteria. Findings are classified by severity (Critical, High, Medium, Low) with remediation examples. Delegates to the typescript-security-expert agent for deep analysis.

Provides structured code review for NestJS applications. Findings categorized by severity (Critical, Warning, Suggestion) with actionable recommendations. Delegates to nestjs-code-review-expert agent for deep analysis.

Provides patterns for data fetching in Next.js App Router: server-side fetching, SWR/React Query integration, ISR, revalidation, error boundaries, and loading states.

Annotation-based and programmatic tool system for LangChain4j agents to execute external functions, APIs, and services. \n \n Define tools using @Tool annotations with parameter descriptions via @P , automatically registered with AI services for LLM invocation \n Supports static tool registration, dynamic tool provisioning based on context, concurrent execution, and immediate-return tools for quick responses \n Includes error handling strategies, tool execution monitoring, memory context integra

Production-grade monitoring, health checks, and metrics configuration for Spring Boot services using Actuator and Micrometer. \n \n Configure endpoint exposure, security policies, and dedicated management ports to isolate operational traffic from application routes \n Set up readiness and liveness health probes with custom indicators for orchestrator integration (Kubernetes, Cloud Foundry) \n Wire Micrometer exporters (Prometheus, OTLP, Wavefront) with application tags for cross-service correlat

Testing Spring Cache annotations without external infrastructure using in-memory cache managers. \n \n Covers testing @Cacheable , @CacheEvict , and @CachePut annotations with patterns for verifying cache hits, misses, and invalidation \n Uses ConcurrentMapCacheManager for fast, isolated unit tests instead of Redis or other external caches \n Includes verification strategies via mock call counts, conditional caching with unless and condition parameters, and custom cache key generation with SpEL

Comprehensive REST API design standards and best practices for Spring Boot applications. \n \n Covers resource-based URL design, HTTP method conventions, status codes, DTOs, validation, and error handling with global exception strategies \n Includes pagination, filtering, sorting, security headers, CORS policies, and HATEOAS implementation patterns \n Provides constructor injection, immutable DTO patterns, transaction management, and logging best practices with code examples \n Enforces API vers

Fault tolerance and resilience patterns for Spring Boot microservices using Resilience4j. \n \n Provides six core patterns: circuit breaker, retry with exponential backoff, rate limiter, bulkhead (semaphore and thread pool), time limiter, and fallback mechanisms \n Annotation-based integration with Spring Boot 3.x AOP; patterns can be stacked on single methods for comprehensive fault tolerance \n Includes configuration examples for all patterns in YAML, with health indicator and Actuator endpoin

Testing Spring ApplicationEvent publishers and listeners with mocked dependencies and event capture patterns. \n \n Mock ApplicationEventPublisher in unit tests and use ArgumentCaptor to verify published events and their data integrity \n Test @EventListener method invocation directly by instantiating listeners and invoking handler methods with captured events \n Handle asynchronous event processing with Thread.sleep() or Awaitility to verify async listener completion \n Verify listener side eff

Standardized MCP server implementation patterns with LangChain4j for extending AI capabilities. \n \n Provides tool providers, resource providers, and prompt template patterns to expose custom capabilities through the Model Context Protocol \n Supports multiple transport mechanisms including stdio for local processes and HTTP for remote servers \n Includes Spring Boot integration, multi-server configuration, and dynamic tool discovery with context-aware filtering \n Implements security patterns

Comprehensive testing patterns for Spring Boot applications covering unit, slice, integration, and container-based tests. \n \n Covers four test types with performance targets: unit tests (< 50ms), slice tests (< 100ms), integration tests (< 500ms), and full context tests with Testcontainers \n Includes patterns for Mockito-based unit testing, JPA/MVC slice testing with focused Spring contexts, and REST API testing with MockMvc and WebTestClient \n Demonstrates Spring Boot 3.5+ @S

JWT authentication and authorization for Spring Boot 3.5.x with token generation, refresh strategies, and role/permission-based access control. \n \n Covers token generation with JJWT, Bearer/cookie authentication, and stateless session management using Spring Security 6.x \n Supports database-backed and OAuth2 provider integration (Google, GitHub) with modern SecurityFilterChain configuration \n Includes refresh token rotation, token blacklisting, and key rotation strategies for production secu

Annotation-driven caching abstraction for Spring Boot service methods with multi-provider support. \n \n Supports multiple cache providers (ConcurrentMap, Caffeine, Redis, Ehcache, JCache) via pluggable CacheManager beans without changing business code \n Provides @Cacheable , @CachePut , @CacheEvict , and @Caching annotations with SpEL-based key generation, conditional caching, and synchronization control \n Includes configuration patterns for TTL, capacity limits, and scheduled eviction; integ

LangChain4J vector store configuration for RAG applications with multiple database backends. \n \n Supports PostgreSQL/pgvector, Pinecone, MongoDB Atlas, Milvus, Neo4j, and in-memory stores with unified abstraction \n Includes document ingestion pipelines with configurable chunking, metadata filtering, and batch operations \n Provides production patterns for connection pooling, health checks, monitoring, and index optimization \n Covers semantic search implementation, multi-store setups, and dim

Type-safe AI services in Java using interface-based patterns, annotations, and declarative configuration. \n \n Define AI capabilities as plain Java interfaces with @SystemMessage and @UserMessage annotations, eliminating manual prompt construction and response parsing \n Built-in memory management for multi-turn conversations with per-user or per-session isolation using @MemoryId and configurable chat memory providers \n Tool integration enables AI services to call external functions and execut

Automated OpenAPI 3.0 documentation generation for Spring Boot 3.x REST APIs with Swagger UI. \n \n Integrates SpringDoc to auto-generate OpenAPI specs from annotated controllers, models, and validation rules without manual configuration \n Supports JWT Bearer, OAuth2, and Basic Auth security documentation with global scheme configuration and per-endpoint security requirements \n Includes comprehensive annotation patterns for documenting endpoints, request/response bodies, parameters, error resp

AWS KMS key management, encryption, and digital signing for Java applications with envelope encryption and Spring Boot integration. \n \n Covers key creation, encryption/decryption, envelope encryption for large data, digital signatures, and key rotation using AWS SDK for Java 2.x \n Includes synchronous and asynchronous client setup, Spring Boot service configuration, and IAM permission patterns \n Provides envelope encryption patterns to reduce KMS API calls and support data larger than 4KB li

AWS Lambda function invocation, management, and Spring Boot integration using AWS SDK for Java 2.x. \n \n Supports synchronous and asynchronous Lambda invocation with JSON payload serialization and typed response parsing \n Covers function lifecycle operations: create, update, delete, list, and retrieve configurations including environment variables and concurrency settings \n Includes Spring Boot integration patterns with bean configuration, service abstractions, and type-safe Lambda invoker se

Modern React 19 patterns for Server Components, Actions, concurrent features, and TypeScript development. \n \n Covers core hooks (useState, useEffect, useRef, useMemo, useCallback) with TypeScript typing and custom hook extraction patterns \n Includes React 19 features: use() hook, useOptimistic, useFormStatus, useFormState, Server Actions, and Server Components with mixed architecture examples \n React Compiler automatic optimization eliminates manual memoization; includes setup, configuration

Production-ready Zod v4 patterns for reusable, type-safe validation with minimal boilerplate. Focuses on modern APIs, predictable error handling, and form integration.

Structured 8-phase workflow for resolving GitHub issues from description to pull request. Uses gh CLI for GitHub API, Context7 for documentation, and coordinates sub-agents for exploration and review.

Interact with Google NotebookLM for advanced RAG capabilities — query project documentation, manage research sources, and retrieve AI-synthesized information from notebooks.

Expert guide for creating and managing a centralized Design System using Tailwind CSS (v4.1+) and shadcn/ui. This skill provides structured workflows for defining design tokens, configuring themes with CSS variables, and building a consistent UI component library based on shadcn/ui primitives.

Patterns for deploying PHP and Symfony applications on AWS Lambda using the Bref framework.

Patterns for creating high-performance AWS Lambda functions in Java with optimized cold starts.

Automatically generates complete CRUD modules for NestJS applications using Drizzle ORM. Creates all necessary files following the zaccheroni-monorepo patterns: feature modules, controllers, services, Zod-validated DTOs, Drizzle schemas, and Jest unit tests.

Provides authentication implementation patterns for Next.js 15+ App Router using Auth.js 5 (NextAuth.js), covering the complete authentication lifecycle from initial setup to production-ready role-based access control implementations.

Patterns for creating high-performance AWS Lambda functions in TypeScript with optimized cold starts.

Patterns for creating high-performance AWS Lambda functions in Python with optimized cold starts and clean architecture.

Better Auth is a type-safe authentication framework for TypeScript supporting multiple providers, 2FA, SSO, organizations, and passkeys. This skill covers integration patterns for NestJS backend with Drizzle ORM + PostgreSQL and Next.js App Router frontend.

Deploy Next.js applications to production with Docker, CI/CD pipelines, and comprehensive monitoring.

Provides guidance for Nx monorepo management in TypeScript/JavaScript projects. Covers workspace creation, project generation, task execution, caching strategies, Module Federation, and CI/CD integration.

Provides guidance for Turborepo monorepo management: workspace creation, turbo.json task configuration, Next.js/NestJS integration, testing pipelines (Vitest/Jest), CI/CD setup, and build performance optimization.

Create professional logical diagrams in draw.io's native XML format for logical flow diagrams, system architecture visualizations, and abstract process representations using generic shapes and symbols.

Build Retrieval-Augmented Generation systems that extend AI capabilities with external knowledge sources.

Amazon Bedrock integration for Java 2.x with support for text generation, embeddings, image generation, and streaming responses. \n \n Covers multiple foundation models (Claude, Llama, Titan, Mistral, Cohere, DeepSeek) with unified API patterns for invoking, listing, and managing models \n Includes streaming response handlers for real-time generation, text embeddings for RAG applications, and image generation with Stable Diffusion \n Provides Spring Boot configuration patterns with dependency in

AWS messaging patterns for SQS queues and SNS topics using Java 2.x SDK. \n \n Covers queue creation, message send/receive, FIFO queues, dead letter queues, and long polling with batch operations \n Supports SNS topic publishing, subscriptions (email, SMS, SQS, Lambda endpoints), and message filtering with attributes \n Includes Spring Boot integration examples with service classes, configuration beans, and property-based resource management \n Provides best practices for visibility timeouts, id

Secure secret storage, retrieval, and rotation using AWS SDK for Java 2.x. \n \n Covers core operations: creating, retrieving, updating, and deleting secrets with version management and automatic rotation support \n Includes SecretCache for production performance optimization with configurable TTL and size limits \n Provides Spring Boot integration patterns including bean configuration, service layers, and database credential management \n Supports JSON-structured secrets for complex credentials

Test @Scheduled and @Async methods directly without waiting for actual execution. \n \n Call async and scheduled methods directly in tests instead of relying on Spring's async executor or scheduling intervals \n Use CompletableFuture.get() with explicit timeouts to wait for async results, and Awaitility.await() for polling-based assertions on state changes \n Mock dependencies that async methods call, then verify interactions after completion using Mockito \n Test exception handling by catching

Type-safe DynamoDB operations using AWS SDK for Java 2.x with Enhanced Client support. \n \n Covers CRUD operations, queries, scans, batch operations, and transactions using the Enhanced Client for type-safe entity mapping with @DynamoDbBean annotations \n Supports composite keys, Global Secondary Indexes (GSI), Local Secondary Indexes (LSI), and advanced filtering with QueryConditional and Expression builders \n Includes Spring Boot integration patterns with repository configuration, dependency

Core patterns and configuration for AWS SDK for Java 2.x service clients, authentication, and HTTP management. \n \n Covers client builder patterns, credential provider chains (environment variables, profiles, IAM roles, SSO), and lifecycle management with try-with-resources \n Supports Apache HTTP client for sync operations and Netty for async, with connection pooling, timeout configuration, and SSL optimization \n Includes Spring Boot integration with @ConfigurationProperties , bean definition

Unit testing patterns for MapStruct mappers and custom converters with comprehensive transformation validation. \n \n Covers field mapping accuracy, null handling, type conversions, nested objects, bidirectional mapping, enum mapping, and partial updates \n Includes Maven and Gradle setup with MapStruct, JUnit 5, and AssertJ dependencies \n Provides patterns for testing simple mappings, nested hierarchies, custom @Mapping annotations, enum @ValueMapping , and @MappingTarget partial updates \n De

AWS RDS instance and snapshot management using AWS SDK for Java 2.x. \n \n Covers core RDS operations: creating and modifying DB instances, managing snapshots, parameter groups, and querying instance metadata across PostgreSQL, MySQL, Aurora, and other engines \n Includes security patterns for VPC configuration, encryption, IAM authentication, and deletion protection; Multi-AZ and automated backup setup for high availability \n Provides Spring Boot and Lambda integration examples with connection

S3 object storage patterns and operations using AWS SDK for Java 2.x. \n \n Covers bucket creation, object uploads/downloads, multipart transfers, presigned URLs, and S3 Transfer Manager for optimized file handling \n Includes synchronous and asynchronous client setup with configurable retry logic, timeouts, and connection pooling \n Provides Spring Boot integration with configuration classes, service layer patterns, and async/reactive workflows \n Supports advanced operations: metadata and encr

Test Spring @ConfigurationProperties bindings, validation, and type conversions without full context startup. \n \n Use ApplicationContextRunner to test property binding in isolation, covering simple properties, nested structures, collections, and type conversions \n Verify validation constraints with @Validated annotations, ensuring invalid values fail appropriately and valid configurations pass \n Test default values, profile-specific configurations, and property name mapping (kebab-case to ca

JUnit 5 parameterized testing patterns for running single test methods with multiple input combinations. \n \n Supports multiple data sources: @ValueSource for simple values, @CsvSource for tabular data, @MethodSource for complex objects, @EnumSource for enum testing, and custom ArgumentsProvider implementations \n Includes boundary value testing, edge case coverage, and systematic validation of multiple scenarios with reduced test duplication \n Offers custom display names for readable test out

Comprehensive testing strategies for LangChain4j applications with mocks, containers, and RAG validation. \n \n Provides unit testing patterns with mock models, integration testing via Testcontainers, and end-to-end workflows for RAG systems, AI Services, and tool execution \n Covers testing pyramid approach: 70% unit tests with mocks, 20% integration tests with real services, 10% end-to-end tests \n Includes specialized patterns for streaming responses, memory management, guardrail assertions,

Unit testing patterns for Spring Security authorization annotations and role-based access control. \n \n Covers @PreAuthorize , @Secured , and @RolesAllowed method-level security with @WithMockUser test fixtures \n Includes role-based access control (RBAC), expression-based authorization, and custom PermissionEvaluator testing \n Provides MockMvc patterns for testing secured REST endpoints and parameterized role testing strategies \n Demonstrates both allow and deny scenarios, owner-based access

Production-ready AWS RDS configuration patterns for Spring Boot applications with Aurora, MySQL, and PostgreSQL. \n \n Supports Aurora MySQL, Aurora PostgreSQL, and standard MySQL/PostgreSQL with datasource configuration, HikariCP connection pooling, and SSL encryption \n Includes environment-specific profiles (dev/prod), Flyway database migrations, and read/write endpoint splitting for read-heavy workloads \n Provides security patterns using environment variables and AWS Secrets Manager integra

Unit testing REST controllers in isolation with MockMvc and mocked service dependencies. \n \n Covers testing all HTTP methods (GET, POST, PUT, PATCH, DELETE) with status code and response body validation using JsonPath assertions \n Includes patterns for request parameter binding, validation errors, exception handling, and content negotiation across different Accept and Content-Type headers \n Uses standalone MockMvc setup with Mockito to mock service layer dependencies, keeping tests focused o

Unit testing patterns for Spring @ExceptionHandler and @ControllerAdvice global exception handlers. \n \n Test exception-to-error-response transformations and HTTP status codes using MockMvc with setControllerAdvice() to register handlers \n Verify error response structure includes required fields (timestamp, status, error, message) and test field-level validation errors from MethodArgumentNotValidException \n Cover multiple exception types with appropriate status codes (404, 409, 401, 403, 500)

Distributed transaction management across microservices using choreography or orchestration patterns. \n \n Supports two saga approaches: choreography-based (event-driven, decoupled) and orchestration-based (centralized coordinator with easier tracking) \n Requires compensating transactions for every forward operation to ensure rollback capability and eventual consistency \n Integrates with Spring Boot 3.x, Kafka, RabbitMQ, and frameworks like Axon Framework, Eventuate Tram, and Camunda \n Empha

Spring Boot auto-configuration and declarative AI services for LangChain4j integration. \n \n Provides property-based configuration for multiple AI providers (OpenAI, Azure, Ollama) with Spring Boot starters and automatic bean wiring \n Enables interface-based AI service definitions using @AiService annotations combined with message templates and Spring dependency injection \n Supports RAG systems through configurable embedding stores (pgvector, Neo4j, Pinecone) and document ingestion pipelines

Unit testing JSON serialization and deserialization with Spring's @JsonTest and Jackson. \n \n Covers serialization/deserialization of POJOs, custom serializers/deserializers, field name mappings with @JsonProperty , and null handling using JacksonTester for type-safe assertions \n Includes patterns for testing nested objects, lists, date/time formatting, and polymorphic types with @JsonTypeInfo \n Provides Maven and Gradle setup, best practices for avoiding circular references and null inclusio

This skill provides comprehensive guidance for implementing Clean Architecture, Hexagonal Architecture (Ports & Adapters), and Domain-Driven Design tactical patterns in Java 21+ Spring Boot 3.5+ applications. It ensures clear separation of concerns, framework-independent domain logic, and highly testable codebases through proper layering and dependency management.

JUnit 5 patterns for testing utility classes, static methods, and pure functions without mocking complexity. \n \n Covers testing strategies for string manipulation, calculations, collections, data validation, and format utilities with edge case and boundary condition handling \n Uses AssertJ assertions for readable test code and @ParameterizedTest for testing multiple similar scenarios efficiently \n Emphasizes null handling, empty inputs, extreme values, and floating-point precision as critica

Advanced prompt patterns for few-shot learning, chain-of-thought reasoning, optimization, templates, and system prompt design. \n \n Covers five core pattern categories: few-shot example selection with semantic diversity, chain-of-thought reasoning traces, iterative optimization workflows with A/B testing, modular template systems with variable interpolation, and comprehensive system prompt architecture \n Includes structured implementation workflows for creating new prompts, optimizing existing

Unit test external REST API integrations with WireMock HTTP mocking and request verification. \n \n Stub HTTP responses with configurable status codes, headers, and JSON bodies; verify request details including headers, query parameters, and request bodies \n Test error scenarios (4xx/5xx responses, timeouts, malformed responses) without calling real APIs or hitting rate limits \n Use dynamic port allocation to avoid conflicts in parallel test execution; automatic cleanup between tests via JUnit

Complete Retrieval-Augmented Generation systems with LangChain4j for knowledge-enhanced AI applications. \n \n Document ingestion pipelines with configurable chunking, metadata management, and embedding generation using OpenAI or custom embedding models \n Vector search and content retrieval with filtering, re-ranking, and configurable similarity thresholds for precise context matching \n RAG-enabled AI services that automatically inject retrieved context into chat models, with support for multi

Spring Data Neo4j integration for graph databases with repositories, Cypher queries, and reactive operations. \n \n Three abstraction levels: Neo4j Client (low-level), Neo4j Template (medium-level), and Neo4j Repositories (high-level query derivation) \n Supports both imperative Neo4jRepository and reactive ReactiveNeo4jRepository patterns; do not mix both in the same application \n Entity mapping with @Node and @Relationship annotations, supporting business keys or generated IDs with immutable

Event-Driven Architecture patterns for Spring Boot using domain events, transactional listeners, and Kafka messaging. \n \n Covers domain event design, ApplicationEventPublisher integration, and @TransactionalEventListener configuration for local event handling with AFTER_COMMIT phase guarantees \n Supports distributed messaging via Kafka and Spring Cloud Stream for inter-service communication with functional consumer beans \n Implements the transactional outbox pattern for reliable event publis

Isolated unit testing patterns for Spring service layer using Mockito and JUnit 5. \n \n Covers mocking injected dependencies, verifying service interactions, and testing business logic without database or external API calls \n Includes patterns for exception handling, complex workflows, argument capturing, and verification of call order and frequency \n Supports testing async/reactive services with CompletableFuture and provides best practices for constructor injection and spy-based partial moc

Constructor-first dependency injection patterns for Spring Boot with optional collaborator handling and bean selection strategies. \n \n Prioritizes constructor injection to keep dependencies explicit, immutable, and testable without Spring context. \n Handles optional dependencies through guarded setters, ObjectProvider, and deterministic no-op defaults. \n Resolves bean ambiguity using @Primary, @Qualifier, profiles, and conditional annotations (@ConditionalOnProperty, @ConditionalOnMissingBea

Optimal chunking strategies for RAG systems and document processing pipelines. \n \n Five strategy levels from fixed-size to advanced methods (late chunking, contextual retrieval), each suited to different document types and complexity \n Includes recursive character chunking with hierarchical separators, structure-aware chunking for Markdown/code/PDFs, and embedding-based semantic chunking with configurable thresholds \n Provides evaluation framework covering retrieval precision, recall, end-to

Build MCP servers with Spring AI using declarative tools, prompt templates, and native Spring integration patterns. \n \n Exposes Spring components as AI-callable tools via @Tool annotation, with parameter documentation through @ToolParam for AI model understanding \n Supports three transport modes (stdio, HTTP, SSE) with built-in Spring Security integration for role-based access control and audit logging \n Includes reusable prompt templates using @PromptTemplate , dynamic tool registration, mu

Feature-aligned CRUD services for Spring Boot 3 with layered architecture and Spring Data JPA. \n \n Establishes feature packages with domain, application, presentation, and infrastructure layers to maintain architectural boundaries and DDD principles. \n Covers complete CRUD workflows: entity modeling with invariants, repository interfaces, JPA adapters, transactional services, DTO records, and REST controllers with proper HTTP status codes. \n Includes validation patterns using jakarta.validat

Generates a fully configured Spring Boot project from scratch using the Spring Initializr API. The skill walks the user through selecting project parameters, choosing an architecture style (DDD or Layered), configuring data stores, and setting up Docker Compose for local development. The result is a build-ready project with standardized structure, dependency management, and configuration.

Systematic JUnit 5 patterns for testing numeric limits, null/empty cases, and edge conditions. \n \n Covers numeric boundaries (Integer.MIN_VALUE, MAX_VALUE, zero), string edge cases (null, empty, whitespace), and collection sizes (empty, single, many) \n Includes parameterized test examples using @ParameterizedTest and @ValueSource for efficient multi-case coverage \n Demonstrates floating-point precision testing with tolerance-based assertions, overflow/underflow detection, and special values

Comprehensive NestJS framework patterns with Drizzle ORM integration for building scalable APIs. \n \n Covers core NestJS concepts: modules, controllers, services, dependency injection, guards, interceptors, and pipes \n Includes complete Drizzle ORM setup with schema definitions, repositories, migrations, and transaction patterns \n Provides authentication and authorization patterns using JWT guards and role-based access control \n Demonstrates testing strategies for unit and e2e tests, validat

Generates comprehensive TypeScript documentation with JSDoc, TypeDoc, and multi-layered patterns for different audiences. \n \n Supports framework-specific documentation for NestJS, Express, React, Angular, and Vue with tailored patterns and examples \n Includes TypeDoc configuration, JSDoc best practices, and automated documentation generation pipelines with GitHub Actions \n Provides architectural decision record (ADR) templates and validation tools to document design decisions alongside code

Unit testing Jakarta Bean Validation constraints and custom validators without Spring context. \n \n Covers testing built-in constraints ( @NotNull , @Email , @Min , @Max , @Size ) and custom @Constraint implementations with violation assertion patterns \n Includes cross-field validation, validation groups for conditional rules, and parameterized test scenarios for multiple inputs \n Provides setup patterns using Validation.buildDefaultValidatorFactory().getValidator() and assertion helpers to e

Qdrant is an AI-native vector database for semantic search and similarity retrieval. This skill provides patterns for integrating Qdrant with Java applications, focusing on Spring Boot and LangChain4j integration.

Automates the process of keeping project documentation synchronized with codebase changes. This skill analyzes git differences between the current working branch and the last released version, then intelligently updates relevant documentation files.

Build modern React applications using Next.js 16+ with App Router architecture.