amplicode/spring-skills
12 skills12 installs648 starsGitHub
Install
npx skills add https://github.com/amplicode/spring-skillsSkills in this repo
1Amplicode Installamplicode-install is an agent skill backed by a PowerShell detector that locates locally installed IntelliJ IDEA (Ultimate or Community) and GigaIDE on Windows. Solo builders shipping Spring or JVM apps with Amplicode often need a machine-readable list of valid IDE homes before plugins or marketplace steps run. The skill runs detect-ides.ps1 (or equivalent) and prints a JSON array of candidates on standard output, or an empty array when nothing is found. Bounded Invoke-WithTimeout and Find-ProductInfoFiles helpers keep scans from blocking indefinitely, which matters when agents automate repetitive environment setup. It fits Claude Code, Cursor, and Codex workflows where filesystem inspection and shell execution are allowed. Pair it with Amplicode marketplace or configuration skills once candidates are known. It does not install plugins by itself—it only discovers where installation should target.1installs2Connekt Script Writerconnekt-script-writer helps solo builders turn described HTTP flows into maintainable Connekt Kotlin scripts. Instead of fragile curl one-liners, you get .connekt.kts files that declare requests declaratively, pull configuration from connekt.env.json, and express checks inside then or useCase blocks where the runner expects them. The skill encodes Connekt’s execution model explicitly: scripts register requests rather than running linearly, which prevents common mistakes like top-level assertions or logic sandwiched between calls. Use it when automating REST checks, chaining authenticated calls, or documenting how an API should behave for future you or CI. It fits backend-heavy SaaS and integration work where Kotlin is already on the classpath via Spring-skills context, and it keeps secrets out of committed scripts by convention.1installs3Crud Rest Controllercrud-rest-controller is a template skill from the Amplicode Spring skills pack. Solo builders shipping Spring Boot APIs use it when an agent is generating or extending a CRUD REST controller and needs consistent dependency injection without guessing Java versus Kotlin idioms. The skill specifies insert points—constructor parameters in Kotlin, fields and constructors in Java—and supplies copy-ready blocks for one bean, multiple beans, or field injection. It pairs naturally with other Spring CRUD skills in the same repo (endpoints, DTO mapping, exception handling) but stands alone as injection boilerplate. Use it whenever the controller class exists but beans are not yet wired; skip it if you already use a project-wide codegen or Lombok pattern that forbids manual snippets. Intermediate familiarity with Spring DI is assumed; the skill does not run tests or modify your build.1installs4Dto Creatordto-creator is an agent skill for Spring and Java backends that scaffolds Data Transfer Object class members from selected entity attributes. Solo builders and small teams use it when they need consistent constructor coverage without hand-copying field lists, especially when mutability rules differ between API response DTOs and internal transfer objects. The skill specifies immutable versus mutable behavior explicitly: immutable DTOs get one all-args constructor, while mutable DTOs must include both no-args and all-args forms even if the user only asked for one. Formatting rules keep parameter lists on a single line and preserve detected project indent units. It also points to a Hibernate-oriented equals and hashCode variant for persistence-aware equality instead of naive field comparison. Install it when you are in active build work and want repeatable DTO structure rather than ad-hoc codegen chat.1installs5Java DebugJava Debug is an agent skill from the Amplicode Spring toolkit that teaches safe, structured use of the IntelliJ debugger through the IntelliJ Debug MCP server. Solo builders shipping Spring APIs can ask the agent to toggle breakpoints, launch debug mode, step through methods, evaluate expressions, and read stack traces instead of guessing from logs alone. The skill opens with a hard preflight: if MCP debug tools are missing, the agent should not pretend to debug remotely. It targets runtime mysteries—nulls, crashes, wrong branches—during feature work and pre-release stabilization. You need IntelliJ with Amplicode installed; it is integration-heavy and intermediate in complexity, not a substitute for writing tests but a accelerator when reproduction requires the live JVM.1installs6Kafka ConfigurationKafka configuration is a code-generation skill for solo builders and small teams adding Apache Kafka to Java Spring Boot 3.2 or newer. It produces a ready-to-drop `@Configuration` block that wires producer and consumer `ProducerConfig` / `ConsumerConfig` properties, serializer and deserializer pairs, and a `ConcurrentKafkaListenerContainerFactory` with sensible default naming. Variables such as package name, type simple names, JSON trusted packages, and listener factory collision handling are spelled out so an agent does not improvise insecure or non-compiling Kafka setup. The skill assumes you have already chosen key and value types and serializer strategy in an earlier Amplicode-style flow. It is narrowly focused on configuration beans—not topic design, ops, or stream processing logic—making it ideal when you want consistent Spring Kafka bootstrap code across services.1installs7Mapper Creatormapper-creator is an Amplicode Spring skill that helps solo builders and small teams emit correct MapStruct after-mapping hooks for JPA-style associations. When you map request DTOs into entities, orphan or one-sided links break cascades and REST contracts; this skill encodes the exact Java fragments for OneToMany collections and optional OneToOne owners using @org.mapstruct.AfterMapping and @MappingTarget. It is aimed at indie SaaS backends on Spring where you generate mappers from entity models rather than hand-writing boilerplate every sprint. Invoke it while scaffolding CRUD modules, Amplicode entity exports, or fixing integration tests that fail because children never received the parent reference. The skill stays narrow: it does not replace full mapper definitions, only the association-linking slice with templated variable substitution from attribute names and mappedBy inverses. That precision reduces copy-paste bugs when your agent adds a new aggregate root in Claude Code or Cursor.1installs8Spring Data Jdbcspring-data-jdbc is an agent skill for solo builders maintaining Spring Data JDBC domains aligned with DDD aggregates. It walks a fixed multi-step ritual: inventory entities, classify aggregate roots versus owned children using MCP tooling, and reconcile @MappedCollection, @Embedded, and AggregateReference patterns against what the database mapping actually expects. The skill treats get_jdbc_entity_details output as authoritative—roots have null aggregateRootFqn, children point to a named root, and referencedBy surfaces incoming links. Install it when you are extending a Java API or modular monolith and need the agent to stop guessing repository boundaries or flattening embeddables into the wrong lifecycle. It suits intermediate-to-advanced backends where JDBC (not JPA) is the persistence choice and Amplicode MCP is available in the workspace.1installs9Spring Data JpaSpring Data JPA is an agent skill that keeps new Hibernate entities consistent with what is already in your Spring Boot codebase. Solo builders use it when adding tables or bounded contexts without introducing a second style of IDs, fetch types, or setter patterns. The workflow deliberately lists domain entities, reads two or three representatives, and scores conventions like SEQUENCE versus IDENTITY, dedicated sequences per table, field-level annotations, and default LAZY associations before writing code. That makes it a strong fit for brownfield SaaS APIs where Amplicode or similar tooling exposes entity inventory. Intermediate complexity assumes you already run Spring Data repositories and want agent-generated entities that pass review on the first pass.1installs10Spring Explorespring-explore is an Amplicode agent skill that acts as a DDD aggregate model analyser for Spring projects using JPA. Solo builders and small teams invoke it when entity graphs feel implicit—ownership is unclear, cascades are risky, or REST resources do not line up with real consistency boundaries. The workflow is MCP-driven: optionally resolve a simple class name to a fully qualified entity name, then pull relationship details and explain which types are aggregate roots, which are members, and the ownership chain from root to each member. That structured view feeds REST path design, DTO boundaries, cascade strategy, and repository queries without guessing from annotations alone. The skill is deliberately narrow: if persistence is not JPA, the readme states aggregate boundaries must be determined elsewhere. Expect to run it during backend build work alongside your Spring codebase and Amplicode MCP server, then apply the model in API and service design. Complexity is intermediate because it assumes familiarity with DDD terms and JPA mapping metadata.1installs11Spring PlanningSpring-planning is an agent skill for solo Java and Spring builders who want plans tied to the real module graph, not generic bullet lists. Before any planning work, the skill enforces an Amplicode MCP preflight: if tools such as get_project_summary or list_module_dependencies are available under the amplicode server (or mcp__amplicode__ prefix), planning proceeds with live IntelliJ-backed context; otherwise the agent must invoke amplicode-install or give marketplace setup steps for IntelliJ IDEA or GigaIDE. The deliverable is a structured implementation plan written into docs/plans with a yyyymmdd task slug, aligning backend feature work with entities and dependencies the MCP exposes. It fits the validate-to-build handoff when scope is firm enough to commit tasks, and remains useful in ship prep when you need a written execution checklist. Intermediate complexity reflects MCP wiring and Spring domain assumptions rather than syntax alone.1installs12Spring Security Configurationspring-security-configuration is an agent skill for solo and indie builders shipping Java APIs who need correct OAuth2 JWT authority mapping without hand-rolling Spring Security boilerplate. It focuses on a single, well-scoped artifact: a package-private JwtAuthenticationConverter helper method that configures JwtGrantedAuthoritiesConverter with the right claims claim and ROLE_ prefix, then attaches it through filterChain via jwtAuthenticationConverter(). The skill encodes Amplicode-style generation rules so you do not accidentally promote the helper to a @Bean or emit converter code when generateConverter is false. Provider-aware variables keep Keycloak and Cognito deployments aligned with how groups and roles appear in tokens. Use it while implementing resource-server security in an existing Spring configuration class, after you have chosen an identity provider and know whether custom authority mapping is required.1installs