A curated collection of reusable skills and agents for automating development tasks in Claude Code — focusing on Java/Spring Boot patterns with extensibility to PHP, TypeScript, and Python
Developer Kit for Claude Code teaches Claude how to perform development tasks in a repeatable way across multiple languages and frameworks. It includes specialized agents for code review, testing patterns, REST API design, and AI integration.
50 Total Skills — Comprehensive coverage of Spring Boot, testing, AI integration, cloud development, AI engineering patterns, and documentation generation
/plugin marketplace add giuseppe-trisciuoglio/developer-kit# Install from marketplace
/plugin marketplace add giuseppe-trisciuoglio/developer-kit
# Or install from local directory
/plugin install /path/to/developer-kit- Go to Settings > Capabilities
- Enable Skills toggle
- Browse available skills or upload custom skills
- Start using in conversations
The Developer Kit now supports installation across multiple AI-powered development environments through a unified Makefile interface.
# Clone the repository
git clone https://github.com/giuseppe-trisciuoglio/developer-kit.git
cd developer-kit-claude-code
# See all available options
make help
# Install for your specific CLI tool
make install-copilot # For GitHub Copilot CLI
make install-opencode # For OpenCode CLI
make install-codex # For Codex CLI
make install # Auto-install for all detected CLIs# Install agents for Copilot CLI
make install-copilot
# Installation creates:
# ~/.copilot/agents/ # Specialized agents for code review, testing, etc.Features:
- 14 Specialized Agents: Code review, architecture, security, testing, debugging experts
- Usage:
/agentto select agents or mention in prompts - Integration: Works with Copilot's native agent system
# Install both agents and commands for OpenCode CLI
make install-opencode
# Installation creates:
# ~/.config/opencode/agent/ # Development agents
# ~/.config/opencode/command/ # Custom slash commandsFeatures:
- 14 Development Agents: Full suite of specialized agents
- 32 Custom Commands: From code generation to debugging and security reviews
- Usage:
@agent-namefor agents,/command-namefor commands - Discovery: Tab completion and command discovery
# Install for Codex CLI
make install-codex
# Installation creates:
# ~/.codex/instructions.md # Agent context and usage guide
# ~/.codex/prompts/ # Custom prompt commandsFeatures:
- 32 Custom Prompts: Specialized commands for development workflows
- 14 Agents Documentation: Complete agent descriptions and usage
- Usage:
/prompts:<name>to invoke custom commands
# Check installation status
make status
# Create backup before installing
make backup
# Remove all Developer Kit installations
make uninstall
# List available components
make list-agents # Show all 14 agents
make list-commands # Show all 32 commands
make list-skills # Show all 50 skills by category- Automatic Backups: Creates timestamped backups before installation
- Conflict Resolution: Preserves existing configurations
- Rollback Support: Easy uninstall to restore previous state
- Version Tracking: Tracks what's installed from this kit
Install skills, agents, and commands directly into your local project for team-based development:
# Clone the repository
git clone https://github.com/giuseppe-trisciuoglio/developer-kit.git
cd developer-kit-claude-code
# Run interactive installer for Claude Code
make install-claudeInteractive Features:
- ✅ Environment Validation: Confirms Claude Code usage
- 🎯 Category Selection: Choose specific skill categories
- 🔧 Custom Selection: Pick specific agents and commands
- 🛡️ Conflict Handling: Decide how to handle existing files
- 📊 Progress Tracking: Real-time installation progress
- 📋 Summary Report: Complete installation summary
$ make install-claude
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Claude Code Interactive Developer Kit Installer
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚠ This installer is designed for Claude Code only.
Are you installing for Claude Code? (y/N): y
Step 1: Target Project
Enter the project path (absolute or relative): ~/my-spring-project
Step 2: Select Skill Categories
Available skill categories:
1) AWS Java Skills (10 skills)
2) AI Skills (3 skills)
3) JUnit Test Skills (15 skills)
4) LangChain4j Skills (8 skills)
5) Spring Boot Skills (13 skills)
6) Spring AI Skills (1 skill)
7) All Skills
8) None (skip skills)
Select categories (comma-separated, e.g., 1,4,5): 4,5
Step 3: Select Agents
1) All Agents (14 available)
2) Select specific agents
3) None (skip agents)
Choose option [1-3]: 2
Available agents:
1) java-documentation-specialist
2) java-refactor-expert
3) java-security-expert
...
Select agents (comma-separated numbers, or type 'all'): 1,3
Step 4: Select Commands
1) All Commands (32 available)
2) Select specific commands
3) None (skip commands)
Choose option [1-3]: 1
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Starting Installation...
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Installing Skills...
Category: LangChain4j Skills
✓ Installed: langchain4j-ai-services-patterns
✓ Installed: langchain4j-mcp-server-patterns
Category: Spring Boot Skills
✓ Installed: spring-boot-actuator
✓ Installed: spring-boot-cache
...
Installing Selected Agents...
✓ Installed: java-documentation-specialist.md
✓ Installed: java-security-expert.md
Installing All Commands...
✓ Installed: devkit.java.code-review.md
✓ Installed: devkit.java.write-unit-tests.md
...
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✓ Installation Complete!
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Target directory: /Users/you/my-spring-project/.claude/
Files installed: 52
Files skipped: 0
Next Steps:
1. Navigate to your project: cd /Users/you/my-spring-project
2. Start Claude Code in the project directory
3. Your skills, agents, and commands are now available!my-project/
├── .claude/
│ ├── skills/ # Auto-discovered skills
│ │ ├── langchain4j-ai-services-patterns/
│ │ ├── spring-boot-actuator/
│ │ └── ... (selected skills)
│ ├── agents/ # @agent-name access
│ │ ├── java-documentation-specialist.md
│ │ ├── java-security-expert.md
│ │ └── ... (selected agents)
│ └── commands/ # /command-name access
│ ├── devkit.java.code-review.md
│ ├── devkit.java.write-unit-tests.md
│ └── ... (selected commands)
For Teams Sharing Projects:
- Install Once: Use
make install-claudein the project root - Git Integration: All
.claude/files are version-controlled - Team Consistency: Everyone gets the same tools and patterns
- Custom Skills: Create project-specific skills shared with team
Benefits:
- 🔄 Consistent Tooling: Team uses same agents, skills, commands
- 📚 Project Context: Skills understand your specific project structure
- 🎯 Domain-Specific: Tailored to your business domain and patterns
- 🚀 Quick Onboarding: New team members get all tools immediately
| Skill | Purpose | Key Topics |
|---|---|---|
| spring-boot-actuator | Production monitoring and metrics | Health checks, custom endpoints, metrics, startup tracking |
| spring-boot-dependency-injection | Constructor injection best practices | DI patterns, testing strategies, anti-patterns |
| spring-boot-crud-patterns | REST CRUD API design with DDD | Feature-based architecture, CRUD generator, Lombok, Spring Data |
| spring-boot-event-driven-patterns | Event-driven architecture | Domain events, Kafka, Spring Cloud Stream, transactional patterns |
| spring-boot-rest-api-standards | REST API design standards | HTTP semantics, error handling, pagination, security headers |
| spring-boot-test-patterns | Integration testing patterns | Testcontainers, Spring slice tests, database strategies |
| spring-boot-cache | Spring Boot caching patterns | Cache configuration, eviction strategies, distributed caching |
| spring-boot-saga-pattern | Distributed transaction management | Saga pattern, choreography, orchestration, compensating transactions |
| spring-boot-resilience4j | Fault tolerance patterns | Circuit breaker, retry, rate limiting, bulkhead patterns |
| spring-boot-security-jwt | JWT authentication & authorization | Bearer tokens, OAuth2/OIDC, RBAC, permission-based access control |
| spring-data-jpa | Spring Data JPA best practices | Query methods, custom repositories, performance optimization |
| spring-data-neo4j | Neo4j graph database integration | Graph modeling, Cypher queries, relationships, reactive mode |
| spring-boot-openapi-documentation | OpenAPI/Swagger documentation | API documentation, schema generation, SpringDoc |
| Skill | Purpose | Key Topics |
|---|---|---|
| unit-test-service-layer | Service layer unit testing | Mocking, assertions, test organization |
| unit-test-controller-layer | Controller layer testing | Mock MVC, request/response handling, status codes |
| unit-test-parameterized | Parameterized tests | JUnit 5 @ParameterizedTest, multiple scenarios |
| unit-test-exception-handler | Exception handling tests | Custom exceptions, error scenarios |
| unit-test-bean-validation | Jakarta Validation testing | Bean validation constraints, custom validators |
| unit-test-security-authorization | Spring Security testing | @WithMockUser, authorization checks, roles |
| unit-test-application-events | Application event testing | Event publishing, listeners, @EventListener |
| unit-test-scheduled-async | Async and scheduled task testing | @Async, @Scheduled, TestScheduler |
| unit-test-json-serialization | JSON serialization testing | Jackson, @JsonTest, custom serializers |
| unit-test-config-properties | Configuration properties testing | @ConfigurationProperties, binding validation |
| unit-test-mapper-converter | Mapper and converter testing | Entity to DTO, custom converters |
| unit-test-caching | Caching layer testing | @Cacheable, cache eviction, hit/miss scenarios |
| unit-test-boundary-conditions | Boundary condition testing | Edge cases, limits, null values |
| unit-test-utility-methods | Utility method testing | Static methods, helpers, common functions |
| unit-test-wiremock-rest-api | REST API mocking with WireMock | HTTP stubs, response matching, status codes |
| Skill | Purpose | Key Topics |
|---|---|---|
| langchain4j-spring-boot-integration | LangChain4J with Spring Boot | Configuration, bean management, integration patterns |
| langchain4j-rag-implementation-patterns | Retrieval-Augmented Generation | Vector stores, retrievers, prompt chaining |
| langchain4j-ai-services-patterns | AI service design | Service patterns, model configuration, error handling |
| langchain4j-mcp-server-patterns | Model Context Protocol servers | MCP integration, tool exposure, data access |
| langchain4j-tool-function-calling-patterns | Tool and function calling | Agent patterns, tool definition, function orchestration |
| langchain4j-testing-strategies | Testing LangChain4J applications | Mock models, test containers, integration tests |
| langchain4j-vector-stores-configuration | Vector store configuration | Embeddings, similarity search, provider setup |
| qdrant-java-development | Qdrant vector database integration | Java, Spring Boot, Langchain4j, RAG, vector search |
| Skill | Purpose | Key Topics |
|---|---|---|
| spring-ai-mcp-server-patterns | Model Context Protocol servers | MCP integration, Spring AI, tool exposure |
| Skill | Purpose | Key Topics |
|---|---|---|
| aws-rds-spring-boot-integration | Aurora RDS configuration with Spring JPA | Cluster setup, connection pooling, read/write split, failover |
| aws-sdk-java-v2-core | AWS SDK v2 core patterns | Client configuration, credential management, async operations |
| aws-sdk-java-v2-s3 | S3 operations with SDK v2 | Bucket operations, object upload/download, presigned URLs |
| aws-sdk-java-v2-dynamodb | DynamoDB operations | Table operations, queries, scans, transactions |
| aws-sdk-java-v2-lambda | Lambda function development | Handler patterns, event processing, custom runtimes |
| aws-sdk-java-v2-secrets-manager | Secrets Manager integration | Secret retrieval, rotation, caching |
| aws-sdk-java-v2-kms | KMS encryption operations | Key management, encryption/decryption, envelope encryption |
| aws-sdk-java-v2-messaging | SQS/SNS messaging patterns | Queue operations, topic publishing, message processing |
| aws-sdk-java-v2-rds | RDS management operations | Instance management, snapshots, parameter groups |
| aws-sdk-java-v2-bedrock | AWS Bedrock AI integration | Model invocation, streaming, guardrails |
| Skill | Purpose | Key Topics |
|---|---|---|
| chunking-strategy | Document chunking for AI systems | Text splitting strategies, semantic chunking, RAG prep |
| prompt-engineering | Advanced prompt design patterns | CoT, few-shot, system prompts, optimization frameworks |
| rag | Retrieval-Augmented Generation patterns | Vector search, document processing, embedding strategies |
| Agent | Specialization | Best For |
|---|---|---|
| spring-boot-code-review-specialist | Spring Boot code review | Architecture, patterns, security review |
| spring-boot-code-review-expert | Expert Spring Boot code review | Advanced code analysis, security, performance review |
| spring-boot-backend-development-expert | Backend development | Implementation, testing, optimization |
| langchain4j-ai-development-expert | AI integration | LangChain4J implementation, RAG, agents |
| spring-boot-unit-testing-expert | Unit testing | Test patterns, Mockito, test organization |
| java-refactor-expert | Java Refactoring | Complex class refactoring, DDD alignment, legacy code modernization |
| java-software-architect-review | Software architecture review | High-level architecture, design patterns, scalability |
| java-security-expert | Java security analysis | Security vulnerabilities, OWASP, secure coding practices |
| java-documentation-specialist | Java project documentation | API docs, architecture guides, technical documentation generation |
| java-tutorial-engineer | Java/Spring Boot tutorials | Educational content, hands-on learning, step-by-step guides |
| prompt-engineering-expert | Prompt engineering | LLM prompt optimization, CoT, few-shot patterns |
| general-debugger | Debugging and root cause analysis | Error troubleshooting, test failures, performance issues |
Specialized — Domain-specific agents for code review, testing, and AI development tailored to Java/Spring Boot
Composable — Skills stack together automatically. Claude identifies which skills are needed and uses them in combination
Portable — Use the same skills across Claude.ai, Claude Code CLI, Claude Desktop, and the Claude API
Efficient — Skills load on-demand, consuming minimal tokens until they're actively used
This kit promotes a feature-based, DDD-inspired architecture for Java/Spring Boot projects:
feature/
├── domain/ # Domain-pure logic
│ ├── model/ # Spring-free entities
│ ├── repository/ # Domain ports (interfaces)
│ └── service/ # Domain services
├── application/ # Use cases & business logic
│ └── service/ # Application services (@Service)
├── presentation/ # HTTP layer
│ ├─ rest/ # REST controllers & mappers
│ └── dto/ # Immutable DTOs/records
└── infrastructure/ # Technical adapters
└── persistence/ # JPA repositories & adapters
- ✅ Constructor injection exclusively (never field injection)
- ✅ Java records (16+) preferred for DTOs
- ✅ Repository pattern with domain interfaces
- ✅ Immutability throughout (
finalfields,@Value, records) - ✅ Clean separation: domain ↔ framework
| Category | Technology | Version |
|---|---|---|
| Java | OpenJDK/GraalVM | 16+ |
| Framework | Spring Boot | 3.x |
| Testing | JUnit 5 (Jupiter) + Mockito + AssertJ | 5.x / 4.x+ |
| Integration Testing | Testcontainers | 1.19.0+ |
| Data | Spring Data JPA | Jakarta Persistence |
| Graph Database | Spring Data Neo4j | 7.x |
| Validation | Jakarta Validation | 3.0+ |
| Utilities | Lombok | 1.18.30+ |
| Messaging | Spring Cloud Stream | 4.x |
| AWS SDK | AWS SDK for Java v2 | 2.20+ |
| Cloud | AWS (RDS Aurora, S3, Lambda, DynamoDB) | Latest |
| AI/ML | LangChain4J, AWS Bedrock | Latest |
Code Review & Architecture — Automated Spring Boot code reviews, architecture validation, security analysis
REST API Design — Standardized API development with proper HTTP semantics, error handling, pagination
Testing Strategies — Unit test patterns, integration testing with Testcontainers, test organization
AI Integration — LangChain4J implementation guidance, RAG patterns, agent development, MCP server creation
Event-Driven Architecture — Domain events, event sourcing patterns, Kafka integration, transactional consistency
AWS Cloud Development — RDS Aurora configuration, S3 operations, Lambda functions, DynamoDB, Secrets Manager, KMS encryption
- Install the skill/agent in Claude Code
- Describe your development task
- Claude will automatically load relevant skills and provide guidance
- Clone or fork this repository
- Customize skills for your team's standards
- Deploy via
/plugin install /path/to/developer-kit-claude-code - Share the plugin marketplace link with your team
This kit includes specialized commands for workflow orchestration, verification, skill validation, and Java development automation:
| Command | Purpose | Use Case |
|---|---|---|
/devkit.generate-changelog |
Generate project changelog | Create and maintain CHANGELOG.md for any project type with Git integration |
/devkit.write-a-minute-of-a-meeting |
Generate meeting minutes from transcripts | Create professional meeting summaries and action items from meeting transcripts or notes |
/devkit.prompt-optimize |
Optimize prompts for better AI performance | Enhance prompt engineering for improved Claude responses and task execution |
| Command | Purpose | Use Case |
|---|---|---|
/devkit.github.create-pr |
Create GitHub pull request | Create branch, commit changes, and submit PR with automated description and commit messages |
/devkit.github.review-pr |
Comprehensive GitHub PR review | Perform code quality, security, performance, architecture, and testing review of a PR |
| Command | Purpose | Use Case |
|---|---|---|
/devkit.java.security-review |
Java enterprise security audit | Comprehensive security review for Spring Boot and Jakarta EE applications (OWASP, CVEs, configs) |
/devkit.ts.security-review |
TypeScript/Node.js security audit | Security review for TypeScript applications (Next.js, NestJS, Express) with OWASP Top 10 analysis |
/devkit.generate-security-assessment |
Generate security assessment document | Create comprehensive security assessment documentation after security audits (English by default) |
| Command | Purpose | Use Case |
|---|---|---|
/speckit.check-integration |
Verify task integration with existing codebase | Run AFTER /speckit.tasks to detect duplication and integration opportunities |
/speckit.optimize |
Optimize execution plan for parallelization | Run AFTER check-integration to plan subagent delegation and resource allocation |
/speckit.verify |
Comprehensive implementation verification | Run AFTER /speckit.implement to validate all requirements, tests, and code quality |
| Command | Purpose | Use Case |
|---|---|---|
/devkit.java.generate-crud |
Generate CRUD implementation for domain class | Create complete REST API with controllers, services, DTOs using spring-boot-crud-patterns |
/devkit.java.generate-docs |
Generate Java project documentation | Create comprehensive API docs, architecture guides, Javadoc, and technical documentation |
/devkit.java.write-unit-tests |
Generate comprehensive JUnit 5 unit tests | Create unit tests with Mockito, AssertJ for Java classes |
/devkit.java.write-integration-tests |
Generate Spring Boot integration tests | Create Testcontainers-based tests for complete workflow testing |
/devkit.java.code-review |
Perform comprehensive Java code review | Review code quality, architecture, security, and performance |
/devkit.java.security-review |
Security-focused code review | Identify vulnerabilities, OWASP compliance, secure coding practices |
/devkit.java.architect-review |
High-level architecture review | Validate design patterns, scalability, and architectural decisions |
/devkit.java.refactor-class |
Intelligent refactoring assistant | Refactor complex Java classes with Clean Architecture, DDD patterns, and Spring Boot best practices |
/devkit.generate-refactoring-tasks |
Generate step-by-step refactoring plan | Create detailed, actionable refactoring tasks for complex Java classes |
/devkit.java.dependency-audit |
Comprehensive dependency audit | Scan vulnerabilities, verify licenses, and get update recommendations |
/devkit.java.upgrade-dependencies |
Safe dependency upgrade strategies | Upgrade dependencies with compatibility testing and rollback procedures |
| Command | Purpose | Use Case |
|---|---|---|
/devkit.generate-changelog |
Generate project changelog | Create and maintain CHANGELOG.md for any project type with multi-language support |
/devkit.write-a-minute-of-a-meeting |
Generate meeting minutes from transcripts | Create professional meeting summaries and action items from meeting transcripts or notes |
/devkit.prompt-optimize |
Optimize prompts for AI performance | Enhance prompt engineering and save optimized prompt to optimized-prompt.md |
| Command | Purpose | Use Case |
|---|---|---|
/devkit.verify-skill |
Validate skill against DevKit standards | Verify a skill's compliance with requirements, format, and best practices |
Commands for managing complex projects that span multiple context windows, based on Anthropic's research on long-running agents.
| Command | Purpose | Use Case |
|---|---|---|
/devkit.lra.init |
Initialize LRA environment | Set up feature list, progress tracking, and init script for multi-session projects |
/devkit.lra.start-session |
Start a new coding session | Read progress, check health, select next feature at the beginning of each session |
/devkit.lra.add-feature |
Add feature to the list | Add new requirements discovered during development |
/devkit.lra.mark-feature |
Mark feature as passed/failed | Update feature status after implementation and testing |
/devkit.lra.checkpoint |
Create session checkpoint | Commit changes, update progress log, ensure clean state at session end |
/devkit.lra.status |
View project status | Display progress metrics, priorities, and recent activity |
/devkit.lra.recover |
Recover from broken state | Diagnose issues, revert if needed, restore working state |
LRA Workflow:
/devkit.lra.init [project-description] ← First time setup
↓
/devkit.lra.start-session ← Start of every session
↓
... implement ONE feature ...
↓
/devkit.lra.mark-feature [id] passed ← After testing
↓
/devkit.lra.checkpoint [summary] ← End of every session
📖 Complete LRA Workflow Guide — Detailed documentation with examples and best practices.
/speckit.tasks
↓
/speckit.check-integration ← Detect existing code & integration opportunities
↓
/speckit.optimize ← Plan parallelization & subagent assignment
↓
/speckit.implement ← Execute with optimization
↓
/speckit.verify ← Verify completeness & quality
/speckit.check-integration
- Analyzes tasks.md for codebase integration opportunities
- Detects duplication risks and existing implementations
- Verifies architectural alignment
- Output: Integration analysis report (READ-ONLY)
- Timing: After task generation, before optimization
/speckit.optimize
- Builds dependency graph and identifies parallelization opportunities
- Allocates tasks to specialized subagents
- Generates phased execution plan with validation checkpoints
- Output: Optimization report with phase execution matrix (READ-ONLY)
- Timing: After integration check, before implementation
/speckit.verify
- Validates all tasks completed
- Confirms requirements coverage
- Runs test suites and checks coverage metrics
- Audits code quality, security, and performance
- Generates verification-report.md
- Output: verification-report.md (PASS/FAIL)
- Timing: After implementation execution
/devkit.verify-skill
- Validates skill compliance with DevKit standards and official Skills documentation
- Checks SKILL.md frontmatter (name, description, allowed-tools, etc.)
- Verifies file structure and syntax (no YAML errors, valid paths)
- Validates content quality (clear triggers, instructions, examples)
- Confirms all referenced files exist in skill directory
- Usage:
/devkit.verify-skill skill-name - Output: Comprehensive validation report with PASS/FAIL status
- Best for: Skill authors before submitting PRs or publishing
/devkit.java.refactor-class
- Intelligent refactoring assistant for complex Java classes
- Applies Clean Architecture, DDD patterns, and Spring Boot best practices
- Supports multiple refactoring scopes: cleanup, architecture, performance, security, testing, comprehensive
- Includes safety checks, backup strategies, and incremental refactoring process
- Usage:
/devkit.java.refactor-class [class-file-path] [refactoring-scope] [options] - Scopes:
cleanup,architecture,performance,security,testing,comprehensive - Options:
dry-run,backup,validate-only - Output: Refactored code with detailed summary of changes and quality metrics
- Best for: Improving code quality, maintainability, and architectural alignment
- ✅ Java/Spring Boot — Comprehensive patterns and agents
- 📋 TypeScript — Node.js, NestJS, Express patterns (planned)
- 📋 Python — Django, FastAPI patterns (planned)
- 📋 PHP — Laravel, Symfony patterns (planned)
- Create
skills/<domain>/<skill-name>/SKILL.md- For Spring Boot:
skills/spring-boot/spring-boot-*/SKILL.md - For JUnit Testing:
skills/junit-test/unit-test-*/SKILL.md - For LangChain4J:
skills/langchain4j/langchain4j-*/SKILL.md - For AWS Java:
skills/aws-java/aws-*/SKILL.md
- For Spring Boot:
- Include YAML frontmatter (name, description, language)
- Add practical examples and best practices
- Document dependencies and commands
- Add supporting files (examples.md, references.md) if needed
- Update marketplace.json with new skill path
- Submit a PR with description and examples
- Create
skills/<new-domain>/directory - Add domain-specific skills following the pattern
- Create corresponding agent if needed
- Follow existing structure for consistency
- Update README.md with new domain section
- Update marketplace.json with new paths
See CONTRIBUTING guidelines for detailed instructions.
Best Practices
- Only install skills from trusted sources
- Review SKILL.md and all scripts before enabling
- Keep skills version-controlled with git
- Audit regularly for updates and changes
- Test in non-production environments first
Comprehensive documentation for all Developer Kit components:
- Spring Boot Skills Guide - Complete guide to Spring Boot patterns including dependency injection, actuator, caching, data persistence, REST APIs, resilience patterns, and testing strategies
- JUnit Testing Skills Guide - Comprehensive testing patterns for controller, service, data, external integrations, infrastructure, and advanced testing scenarios
- LangChain4j Skills Guide - Building AI-powered applications with core integration, AI services, RAG implementation, vector stores, and MCP server patterns
- AWS Java SDK Skills Guide - Cloud development with AWS services including core SDK setup, storage (S3), databases (DynamoDB, RDS), compute (Lambda), messaging (SQS/SNS), and security services
- Agents Guide - Complete documentation for specialized agents including Java development, testing & quality, AI & LangChain4j, documentation, and engineering agents
- Commands Guide - Comprehensive command reference for Java/Spring Boot development, testing, DevKit management, and utility commands with practical workflows
- LRA Workflow Guide - Long-Running Agent workflow for multi-session projects based on Anthropic's research on effective agent harnesses
- What are Skills? — Claude support article
- Using Skills in Claude — Setup guide
- Claude Developer Platform — Official docs
- Skills API Documentation — API reference
- anthropics/skills — Official Anthropic skills repository
- awesome-claude-skills — Community skills collection
- obra/superpowers — Battle-tested skills library
This project is licensed under the LICENSE file in the repository root. See that file for details.
- Questions? Open an issue
- Contributions? Submit a pull request
- Integration proposals? Create a discussion or reach out
For a complete history of changes, please see the dedicated CHANGELOG.md file.
Recent highlights:
- v1.15.0:
- New comprehensive Makefile with multi-CLI support for GitHub Copilot CLI, OpenCode CLI, and Codex CLI
- Interactive Claude Code installer (
make install-claude) with category-based skill selection, conflict handling, and project-specific installation - Support for team-based development with version-controlled
.claude/configurations - Enhanced installation management with backup, status, and uninstall capabilities
- v1.14.0:
- New spring-boot-security-jwt skill with JWT authentication patterns, OAuth2/OIDC integration, and permission-based access control
- New spring-ai-mcp-server-patterns for Model Context Protocol integration
- Enhanced
/devkit.feature-developmentcommand with AskUserQuestion tool and improved agent fallback order
- v1.13.0: New
/devkit.feature-developmentcommand with systematic 9-phase approach for guided feature development, including three new general-purpose agents (explorer, architect, reviewer) with Task tool integration and fallback mechanism - v1.12.1: Fixed commands for correct agent selection on execution
- v1.12.0: Long-Running Agent (LRA) workflow commands and guide for multi-session project management
- v1.11.0: Enhanced development workflow with new commands, agents, and comprehensive documentation updates
- v1.10.0: GitHub integration and workflow automation with PR creation and review commands
- v1.9.0: Documentation generation commands and educational content expansion
Made with ❤️ for Java/Spring Boot developers using Claude Code