Agent skill

Spring Boot Project Creator

by giuseppe-trisciuoglio in giuseppe-trisciuoglio/developer-kit

Creates and scaffolds a new Spring Boot project (3.x or 4.x) by downloading from Spring Initializr, generating package structure (DDD or Layered architecture), configuring JPA, SpringDoc OpenAPI…

MITAuto-check: notesBackend & APIs

Install Spring Boot Project Creator

skills CLI
$ npx skills add giuseppe-trisciuoglio/developer-kit --skill spring-boot-project-creator -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install giuseppe-trisciuoglio/developer-kit spring-boot-project-creator --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/giuseppe-trisciuoglio/developer-kit.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/developer-kit-java/skills/spring-boot-project-creator .claude/skills/spring-boot-project-creator && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
spring-boot-project-creator
GitHub stars
357
Token cost
~3.4k tokens
SKILL.md length
884 words
Files
1
Skills in repo
115
Repo updated
First seen
Licence
MIT

At a glance

Creates and scaffolds a new Spring Boot project (3.x or 4.x) by downloading from Spring Initializr, generating package structure (DDD or Layered architecture), configuring JPA, SpringDoc OpenAPI…

  • Works in 10 steps: Gather Project Configuration → Generate Project with Spring Initializr → Add Additional Dependencies → …
  • Creating a new Java Spring Boot project from scratch
  • SKILL.md covers Overview, When to Use, Prerequisites and Instructions, plus 4 more sections
  • Calls curl; reaches start.spring.io; needs POSTGRES_PASSWORD and REDIS_PASSWORD

What it does

Spring Boot Project Creator is an agent skill from giuseppe-trisciuoglio/developer-kit. Creates and scaffolds a new Spring Boot project (3.x or 4.x) by downloading from Spring Initializr, generating package structure (DDD or Layered architecture), configuring JPA, SpringDoc OpenAPI, and Docker Compose services (PostgreSQL, Redis, MongoDB). Use when creating a new Java Spring Boot project from scratch, bootstrapping a microservice, or initializing a backend application.

Its SKILL.md is about 3.4k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Backend & APIs, covering Backend development, Domain-driven design and Containers. It works with Spring Boot, Docker, Java and MongoDB. The repository describes itself as: Modular plugin marketplace for Claude Code and agentic CLIs, with validated, spec-driven skills, agents, commands, and workflows for Java, TypeScript, Python, PHP, AWS, and AI. The licence is MIT.

When your agent uses it

  • Creating a new Java Spring Boot project from scratch
  • Bootstrapping a microservice
  • Initializing a backend application

Example prompts

  • “Use the spring-boot-project-creator skill to create and scaffolds a new Spring Boot project (3.x or 4.x) by downloading from Spring Initializr…”
  • “/spring-boot-project-creator”

Requirements

  • Docker
  • Pre-approved tools (allowed-tools): Read, Write, Edit, Bash, Glob, Grep, AskUserQuestion

Workflow steps

10 steps, taken from the step headings in SKILL.md.

  1. Gather Project Configuration
  2. Generate Project with Spring Initializr
  3. Add Additional Dependencies
  4. Create Architecture Structure
  5. Configure Application Properties
  6. Set Up Docker Compose
  7. Create .env File for Docker Compose
  8. Update .gitignore
  9. Verify the Build
  10. Present Summary to User

What it can do on your machine

Read from SKILL.md and the folder at commit fe73fb3. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Write
    • Edit
    • Bash
    • Glob
    • Grep
    • AskUserQuestion

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • curl

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • start.spring.io

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • POSTGRES_PASSWORD
    • REDIS_PASSWORD
    • MONGO_PASSWORD
    • MONGO_INITDB_ROOT_PASSWORD

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Spring Boot Project Creator loads about 3.4k tokens when it runs. Until then it costs about 103 tokens; SKILL.md has 884 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~103
When it runs · the whole SKILL.md, loaded when a task matches
~3.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NoteMentions a .env fileSKILL.md:241
    ### 7. Create `.env` File for Docker Compose
  • NoteMentions a .env fileSKILL.md:243
    Create a `.env` file at the project root with default credentials for local development:
  • NoteMentions a .env fileSKILL.md:264
    cker Compose volume directories and the `.env` file to `.gitignore`:
  • NoteMentions a .env fileSKILL.md:268
    .env
  • NoteMentions a .env fileSKILL.md:387
    ker Compose credentials are loaded from `.env` file (git-ignored) — never commit secrets to version control.
  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Read, Write, Edit, Bash, Glob, Grep, AskUserQuestion

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from giuseppe-trisciuoglio/developer-kit at commit fe73fb3, republished under its MIT licence (© giuseppe-trisciuoglio). 884 words, ~3,350 tokens.

Download SKILL.mdSave it as .claude/skills/spring-boot-project-creator/SKILL.md (or your agent's skills folder).
name
spring-boot-project-creator
description
Creates and scaffolds a new Spring Boot project (3.x or 4.x) by downloading from Spring Initializr, generating package structure (DDD or Layered architecture), configuring JPA, SpringDoc OpenAPI, and Docker Compose services (PostgreSQL, Redis, MongoDB). Use when creating a new Java Spring Boot project from scratch, bootstrapping a microservice, or initializing a backend application.
allowed-tools
Read, Write, Edit, Bash, Glob, Grep, AskUserQuestion

Spring Boot Project Creator

Overview

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.

When to Use

  • Bootstrap a new Spring Boot 3.x or 4.x project with a standard structure.
  • Initialize a backend microservice with JPA, SpringDoc OpenAPI, and Docker Compose.
  • Scaffold a project following either DDD (Domain-Driven Design) or Layered (Controller/Service/Repository/Model) architecture.
  • Set up local development infrastructure with PostgreSQL, Redis, and/or MongoDB via Docker Compose.
  • Trigger phrases: "create spring boot project", "new spring boot app", "bootstrap java project", "scaffold spring boot microservice", "initialize spring boot backend", "generate spring boot project".

Prerequisites

Before starting, ensure the following tools are installed:

  • Java Development Kit (JDK): Version 17+ (Java 21 recommended for Spring Boot 3.x/4.x)
  • Apache Maven: Build tool (Spring Initializr generates Maven projects by default)
  • Docker and Docker Compose: For running local infrastructure services
  • curl and unzip: For downloading and extracting the project from Spring Initializr

Instructions

Follow these steps to create a new Spring Boot project.

1. Gather Project Configuration

Ask the user for the following project parameters using AskUserQuestion. Provide sensible defaults:

ParameterDefaultOptions
Group IDcom.exampleAny valid Java package name
Artifact IDdemoKebab-case identifier
Package NameSame as Group IDValid Java package
Spring Boot Version3.4.53.4.x, 4.0.x (check start.spring.io for latest)
Java Version2117, 21
ArchitectureUser choiceDDD or Layered
Docker ServicesUser choicePostgreSQL, Redis, MongoDB (multi-select)
Build Toolmavenmaven, gradle
2. Generate Project with Spring Initializr

Use curl to download the project scaffold from start.spring.io.

Base dependencies (always included):

  • web — Spring Web MVC
  • validation — Jakarta Bean Validation
  • data-jpa — Spring Data JPA
  • testcontainers — Testcontainers support

Conditional dependencies (based on Docker Services selection):

  • PostgreSQL selected → add postgresql
  • Redis selected → add data-redis
  • MongoDB selected → add data-mongodb
bash
# Example for Spring Boot 3.4.5 with PostgreSQL only
curl -s https://start.spring.io/starter.zip \
  -d type=maven-project \
  -d language=java \
  -d bootVersion=3.4.5 \
  -d groupId=com.example \
  -d artifactId=demo \
  -d packageName=com.example \
  -d javaVersion=21 \
  -d packaging=jar \
  -d dependencies=web,data-jpa,postgresql,validation,testcontainers \
  -o starter.zip

unzip -o starter.zip -d ./demo
rm starter.zip
cd demo
3. Add Additional Dependencies

Edit pom.xml to add SpringDoc OpenAPI and ArchUnit for architectural testing.

xml
<!-- SpringDoc OpenAPI -->
<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>2.8.15</version>
</dependency>

<!-- ArchUnit for architecture tests -->
<dependency>
    <groupId>com.tngtech.archunit</groupId>
    <artifactId>archunit-junit5</artifactId>
    <version>1.4.1</version>
    <scope>test</scope>
</dependency>
4. Create Architecture Structure

Based on the user's choice, create the package structure under src/main/java/<packagePath>/.

Option A: Layered Architecture
src/main/java/com/example/
├── controller/        # REST controllers (@RestController)
├── service/           # Business logic (@Service)
├── repository/        # Data access (@Repository, Spring Data interfaces)
├── model/             # JPA entities (@Entity)
│   └── dto/           # Request/Response DTOs (Java records)
├── config/            # Configuration classes (@Configuration)
└── exception/         # Custom exceptions and @ControllerAdvice

Create placeholder classes for each layer:

  • config/OpenApiConfig.java — SpringDoc OpenAPI configuration bean
  • exception/GlobalExceptionHandler.java — @RestControllerAdvice with standard error handling
  • model/dto/ErrorResponse.java — Standard error response record
Option B: DDD (Domain-Driven Design) Architecture
src/main/java/com/example/
├── domain/                 # Core domain (framework-free)
│   ├── model/              # Entities, Value Objects, Aggregates
│   ├── repository/         # Repository interfaces (ports)
│   └── exception/          # Domain exceptions
├── application/            # Use cases / Application services
│   ├── service/            # @Service orchestration
│   └── dto/                # Input/Output DTOs (records)
├── infrastructure/         # External adapters
│   ├── persistence/        # JPA entities, Spring Data repos
│   └── config/             # Spring @Configuration
└── presentation/           # REST API layer
    ├── controller/         # @RestController
    └── exception/          # @RestControllerAdvice

Create placeholder classes for each layer:

  • infrastructure/config/OpenApiConfig.java — SpringDoc OpenAPI configuration bean
  • presentation/exception/GlobalExceptionHandler.java — @RestControllerAdvice with standard error handling
  • application/dto/ErrorResponse.java — Standard error response record
5. Configure Application Properties

Create src/main/resources/application.properties with the selected services.

Always include:

properties
# Application
spring.application.name=${artifactId}

# SpringDoc OpenAPI
springdoc.swagger-ui.doc-expansion=none
springdoc.swagger-ui.operations-sorter=alpha
springdoc.swagger-ui.tags-sorter=alpha

If PostgreSQL is selected:

properties
# PostgreSQL / JPA
spring.datasource.driver-class-name=org.postgresql.Driver
spring.datasource.url=jdbc:postgresql://localhost:5432/${POSTGRES_DB:postgres}
spring.datasource.username=${POSTGRES_USER:postgres}
spring.datasource.password=${POSTGRES_PASSWORD:changeme}
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

If Redis is selected:

properties
# Redis
spring.data.redis.host=localhost
spring.data.redis.port=6379
spring.data.redis.password=${REDIS_PASSWORD:changeme}

If MongoDB is selected:

properties
# MongoDB
spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.authentication-database=admin
spring.data.mongodb.username=${MONGO_USER:root}
spring.data.mongodb.password=${MONGO_PASSWORD:changeme}
spring.data.mongodb.database=${MONGO_DB:test}
6. Set Up Docker Compose

Create docker-compose.yaml at the project root with only the services the user selected.

yaml
services:
  # Include if PostgreSQL selected
  postgresql:
    image: postgres:17
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: ${POSTGRES_USER:-postgres}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-changeme}
      POSTGRES_DB: ${POSTGRES_DB:-postgres}
    volumes:
      - ./postgres_data:/var/lib/postgresql/data

  # Include if Redis selected
  redis:
    image: redis:7
    ports:
      - "6379:6379"
    command: redis-server --requirepass ${REDIS_PASSWORD:-changeme}
    volumes:
      - ./redis_data:/data

  # Include if MongoDB selected
  mongodb:
    image: mongo:8
    ports:
      - "27017:27017"
    environment:
      MONGO_INITDB_ROOT_USERNAME: ${MONGO_USER:-root}
      MONGO_INITDB_ROOT_PASSWORD: ${MONGO_PASSWORD:-changeme}
    volumes:
      - ./mongo_data:/data/db
7. Create .env File for Docker Compose

Create a .env file at the project root with default credentials for local development:

env
# PostgreSQL
POSTGRES_USER=postgres
POSTGRES_PASSWORD=changeme
POSTGRES_DB=postgres

# Redis
REDIS_PASSWORD=changeme

# MongoDB
MONGO_USER=root
MONGO_PASSWORD=changeme
MONGO_DB=test

Include only the variables for the services the user selected. Docker Compose automatically loads this file.

8. Update .gitignore

Append Docker Compose volume directories and the .env file to .gitignore:

# Docker Compose
.env
postgres_data/
redis_data/
mongo_data/
9. Verify the Build

Run the Maven build to confirm the project compiles and tests pass:

bash
./mvnw clean verify

If the build succeeds, inform the user. If it fails, diagnose and fix the issue before proceeding.

Show full SKILL.md (344 more words)Show less
10. Present Summary to User

Display a summary of the created project:

Project Created Successfully

  Artifact:      <artifactId>
  Spring Boot:   <version>
  Java:          <javaVersion>
  Architecture:  <DDD | Layered>
  Build Tool:    Maven
  Docker:        <services list>

  Directory:     ./<artifactId>/

  Next Steps:
    1. cd <artifactId>
    2. docker compose up -d
    3. ./mvnw spring-boot:run
    4. Open http://localhost:8080/swagger-ui.html

Architecture Patterns

Layered Architecture

Traditional three-tier architecture with clear separation of concerns:

LayerPackageResponsibility
Presentationcontroller/HTTP endpoints, request/response mapping
Businessservice/Business logic, transaction management
Data Accessrepository/Database operations via Spring Data
Domainmodel/JPA entities and DTOs

Best for: Simple CRUD applications, small-to-medium services, teams new to Spring Boot.

DDD Architecture

Domain-Driven Design with hexagonal boundaries:

LayerPackageResponsibility
Domaindomain/Entities, value objects, domain services (framework-free)
Applicationapplication/Use cases, orchestration, DTO mapping
Infrastructureinfrastructure/JPA adapters, external integrations, configuration
Presentationpresentation/REST controllers, error handling

Best for: Complex business domains, microservices with rich logic, long-lived projects.

Examples

Example 1: Simple REST API with PostgreSQL (Layered)

User request: "Create a Spring Boot project for a REST API with PostgreSQL"

bash
curl -s https://start.spring.io/starter.zip \
  -d type=maven-project \
  -d bootVersion=3.4.5 \
  -d groupId=com.example \
  -d artifactId=my-api \
  -d packageName=com.example.myapi \
  -d javaVersion=21 \
  -d dependencies=web,data-jpa,postgresql,validation,testcontainers \
  -o starter.zip

Result: Layered project with controller/, service/, repository/, model/ packages, PostgreSQL Docker Compose, and SpringDoc OpenAPI.

Example 2: Microservice with DDD and Multiple Stores

User request: "Bootstrap a Spring Boot 3 microservice with DDD, PostgreSQL and Redis"

bash
curl -s https://start.spring.io/starter.zip \
  -d type=maven-project \
  -d bootVersion=3.4.5 \
  -d groupId=com.acme \
  -d artifactId=order-service \
  -d packageName=com.acme.order \
  -d javaVersion=21 \
  -d dependencies=web,data-jpa,postgresql,data-redis,validation,testcontainers \
  -o starter.zip

Result: DDD project with domain/, application/, infrastructure/, presentation/ packages, PostgreSQL + Redis Docker Compose, and SpringDoc OpenAPI.

Best Practices

  • Always use Spring Initializr for project generation to get the correct dependency management and parent POM.
  • Use Java records for DTOs — they are immutable and concise.
  • Keep domain layer framework-free in DDD architecture — no Spring annotations in domain/.
  • Use environment variables for sensitive configuration in production (database passwords, etc.).
  • Pin Docker image versions in docker-compose.yaml to avoid unexpected breaking changes.
  • Run ./mvnw clean verify after setup to ensure everything compiles and tests pass.
  • Add Testcontainers for integration tests instead of relying on Docker Compose.

Constraints and Warnings

  • Spring Initializr requires internet access — this skill cannot work offline.
  • Spring Boot 4.x availability depends on the current release cycle — check start.spring.io for latest versions.
  • Docker Compose credentials are loaded from .env file (git-ignored) — never commit secrets to version control.
  • The spring.jpa.hibernate.ddl-auto=update setting is for development only — use Flyway or Liquibase in production.
  • ArchUnit version must be compatible with the JUnit 5 version bundled with Spring Boot.

© giuseppe-trisciuoglio, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in plugins/developer-kit-java/skills/spring-boot-project-creator of giuseppe-trisciuoglio/developer-kit.

Open the folder on GitHubat commit fe73fb3

Compare with similar skills

Spring Boot Project Creator next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Spring Boot Project Creator compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Spring Boot Project Creator this skillgiuseppe-trisciuoglio/developer-kit357—~3.4kAutomated safety check: NotesMIT
Dr Jskilljdubois/dr-jskill342—~4.6kAutomated safety check: NotesApache-2.0
Create Spring Boot Java Projectgithub/awesome-copilot40k1 repos~1.1kAutomated safety check: PassMIT
Springboot Init Skilljiushiwon/wg-skills114—~2.2kAutomated safety check: NotesApache-2.0
Create Spring Boot Kotlin Projectgithub/awesome-copilot40k1 repos~1kAutomated safety check: PassMIT
Use Sealoshashgraph-online/awesome-codex-plugins1.3k—~2.2kAutomated safety check: PassApache-2.0

Similar skills

  • Dr Jskill

    jdubois/dr-jskill

    Creates Java + Spring Boot projects: Web applications, full-stack apps with Vue.js or Angular or React or vanilla JS, PostgreSQL, REST APIs, and Docker.

    342 GitHub stars~4.6k tokensUpdated 11 days ago
    Backend & APIsAuto-check: notes
  • Create Spring Boot Java Project

    github/awesome-copilot

    Official

    Create Spring Boot Java Project Skeleton. An agent skill from github/awesome-copilot.

    40k GitHub starsUsed in 1 repo~1.1k tokens
    Backend & APIsAuto-check passed
  • Springboot Init Skill

    jiushiwon/wg-skills

    Spring Boot 项目一键初始化技能。面向零基础小白,提供环境探测、自动安装、完整 Web 骨架生成、SSE 流式框架、JWT 鉴权、统一响应封装、文件上传接口、一键启动/重启脚本、Swagger 文档,内置 MySQL(默认)/ PostgreSQL / MongoDB 数据库选择。用户只需说"帮我搭一个 Spring Boot…

    114 GitHub stars~2.2k tokensUpdated 4 days ago
    Backend & APIsAuto-check: notes
  • Create Spring Boot Kotlin Project

    github/awesome-copilot

    Official

    Create Spring Boot Kotlin Project Skeleton. An agent skill from github/awesome-copilot.

    40k GitHub starsUsed in 1 repo~1k tokens
    Backend & APIsAuto-check passed
  • Use Sealos

    hashgraph-online/awesome-codex-plugins

    Deploy and operate apps on Sealos Cloud: sign in to a Sealos account, deploy any project or self-hosted app (from the template store, an official Docker image, or project source code), provision…

    1.3k GitHub stars~2.2k tokensUpdated yesterday
    DatabasesAuto-check passed
  • Spring Boot

    piomin/claude-ai-spring-boot

    Spring Boot 3.x development - REST APIs, JPA, Security, Testing, and Cloud-native patterns.

    1.3k GitHub stars~2k tokensUpdated 5 mo ago
    Backend & APIsAuto-check passed

More from giuseppe-trisciuoglio/developer-kit

All 115 skills in this repo
  • Nestjs Drizzle Crud Generator

    giuseppe-trisciuoglio/developer-kit

    Generates complete CRUD modules for NestJS applications with Drizzle ORM.

    357 GitHub stars~1.3k tokensUpdated 1 mo ago
    Auto-check: notes
  • Spring Boot Actuator

    giuseppe-trisciuoglio/developer-kit

    Provides patterns to configure Spring Boot Actuator for production-grade monitoring, health probes, secured management endpoints, and Micrometer metrics across JVM services.

    357 GitHub stars~2.2k tokensUpdated 1 mo ago
    Auto-check: notes
  • Spring Boot Crud Patterns

    giuseppe-trisciuoglio/developer-kit

    Provides and generates complete CRUD workflows for Spring Boot 3 services.

    357 GitHub stars~2.5k tokensUpdated 1 mo ago
    Auto-check: notes
  • Spring Boot Security JWT

    giuseppe-trisciuoglio/developer-kit

    Provides JWT authentication and authorization patterns for Spring Boot 3.5.x covering token generation with JJWT, Bearer/cookie authentication, database/OAuth2 integration, and RBAC/permission-based…

    357 GitHub stars~3.9k tokensUpdated 1 mo ago
    Auto-check: notes
  • AWS CLI Beast

    giuseppe-trisciuoglio/developer-kit

    Provides advanced AWS CLI patterns for managing EC2, Lambda, S3, DynamoDB, RDS, VPC, IAM, and CloudWatch.

    357 GitHub stars~1.7k tokensUpdated 1 mo ago
    Auto-check: notes
  • PR Review Comments

    giuseppe-trisciuoglio/developer-kit

    Posts review findings from a JSON file as inline comments on a GitHub Pull Request, attaching each comment to its file and line.

    357 GitHub stars~1k tokensUpdated 1 mo ago
    Auto-check: notes

Categories

Questions about Spring Boot Project Creator

What does Spring Boot Project Creator do?

Creates and scaffolds a new Spring Boot project (3.x or 4.x) by downloading from Spring Initializr, generating package structure (DDD or Layered architecture), configuring JPA, SpringDoc OpenAPI…. Spring Boot Project Creator is an agent skill from giuseppe-trisciuoglio/developer-kit.x) by downloading from Spring Initializr, generating package structure (DDD or Layered architecture), configuring JPA, SpringDoc OpenAPI, and Docker Compose services (PostgreSQL, Redis, MongoDB).

When should I use Spring Boot Project Creator?

Spring Boot Project Creator fits situations like: creating a new Java Spring Boot project from scratch; bootstrapping a microservice; initializing a backend application.

How do I install Spring Boot Project Creator in Claude Code?

Run `npx skills add giuseppe-trisciuoglio/developer-kit --skill spring-boot-project-creator -a claude-code`. Or copy the skill folder (plugins/developer-kit-java/skills/spring-boot-project-creator in giuseppe-trisciuoglio/developer-kit) into .claude/skills/spring-boot-project-creator in your project. Claude Code loads it when a task matches its description.

How do I install Spring Boot Project Creator in Codex?

Run `npx skills add giuseppe-trisciuoglio/developer-kit --skill spring-boot-project-creator -a codex`. Or copy the skill folder (plugins/developer-kit-java/skills/spring-boot-project-creator in giuseppe-trisciuoglio/developer-kit) into .agents/skills/spring-boot-project-creator in your project. Codex loads it when a task matches its description.

Can I use Spring Boot Project Creator in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add giuseppe-trisciuoglio/developer-kit --skill spring-boot-project-creator -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/spring-boot-project-creator, .gemini/skills/spring-boot-project-creator, .github/skills/spring-boot-project-creator and .opencode/skills/spring-boot-project-creator in your project.

What does Spring Boot Project Creator need to run?

Going by SKILL.md and its folder, Spring Boot Project Creator needs the command-line tools its instructions call (curl) and credentials named POSTGRES_PASSWORD, REDIS_PASSWORD, MONGO_PASSWORD and MONGO_INITDB_ROOT_PASSWORD. Our summary lists: Docker. Its frontmatter pre-approves these tools: Read, Write, Edit, Bash, Glob, Grep, AskUserQuestion.

Does Spring Boot Project Creator access the network?

SKILL.md names 1 domain. In commands or code: start.spring.io; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Spring Boot Project Creator safe to install?

Our automated static check of SKILL.md found notes only (mentions a .env file; pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Spring Boot Project Creator use?

Spring Boot Project Creator is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Spring Boot Project Creator use?

About 3.4k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Spring Boot Project Creator?

Skills that share tags, products or a category with Spring Boot Project Creator: Dr Jskill (jdubois/dr-jskill, 342 stars), Create Spring Boot Java Project (github/awesome-copilot, 40k stars), Springboot Init Skill (jiushiwon/wg-skills, 114 stars) and Create Spring Boot Kotlin Project (github/awesome-copilot, 40k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Spring Boot Project Creator?

giuseppe-trisciuoglio (a GitHub user) maintains it in giuseppe-trisciuoglio/developer-kit, which has 357 GitHub stars. The repository holds 115 skills in this directory. The repository was last updated on September 10, 2026.

Source: giuseppe-trisciuoglio/developer-kit on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.