amplicode

get_project_summary

list_module_dependencies

get_entity_details

mcp__amplicode__

• If at least one Amplicode tool is available — MCP is connected. Proceed with the skill below.
• If none are available — stop and invoke the

  amplicode-install

  skill (bundled with the Spring Agent Toolkit). It installs the Amplicode plugin and walks the user through the «Настроить Spring Agent» welcome-screen button + MCP-client restart. After it completes, the MCP tools become available — resume this skill.
• If

  amplicode-install

  is not registered in your skill list, tell the user (in their language): "This skill needs the Amplicode IntelliJ plugin and its MCP server. Install it from https://amplicode.ru/marketplace into IntelliJ IDEA Ultimate/Community or GigaIDE, open any project, click «Настроить Spring Agent» on the Amplicode welcome screen, then restart your MCP client."

@RestController

CRITICAL: Code ONLY from examples/ files. If no matching example -- STOP and ask user. CRITICAL: For questions with a fixed set of choices, prefer

AskUserQuestion

> its analogue > plain text list. Plain numbered text lists are the last resort when no interactive tool is available. CRITICAL: Read the conversation context BEFORE running Step 1. Half the questions in Steps 2–4 may already be answered by the user's prompt and prior turns. Re-asking what was already said is the #1 reason this skill feels slow.

get_project_summary

get_project_summary

• Question "Which entity?" --> user answers "Product" --> this IS the entity, don't re-ask
• Question "Repository?" --> user answers "ProductRepository" --> this IS the choice
• If user provides multiple answers in one message --> accept all, skip answered questions
• NEVER ask a question that the user already answered (even implicitly)

AskUserQuestion

• Belong to the same logical section
• Don't depend on each other's answers

• Maximum 3-4 questions per

  AskUserQuestion

  call
• Mark the recommended option with

  (Recommended)

  and place it first
• Never batch questions from DIFFERENT decision branches
• The primary branching question (entity selection) is always asked ALONE
• Prefer

  AskUserQuestion

  for choices; fall back to plain text lists only if the tool is unavailable

1. Context is unambiguous → decide silently, do NOT ask. Examples: language and JDK from

   get_project_summary

   ; repository when there is exactly one for the entity; controller package from existing controllers; basePath from existing endpoints; Jackson version from

   list_module_dependencies

   ; pagination type when project already uses one consistently.
2. Context gives a strong signal → state the decision + alternatives in one line, let the user override or stay silent. Format:

   Will create `ProductController` at `/rest/products` with Page pagination, no DTO.
   Alternatives: use DTO, Window pagination, custom paths. OK?

   The user can answer "ok" / "yes" / silence → accept; or name an alternative → switch. This is not the same as the numbered question format — it is a single confirmation line.
3. Context yields no clear default → ask with

   AskUserQuestion

   (preferred) or its analogue, with the recommended option first. When

   AskUserQuestion

   is available, use it with the recommended option marked

   (Recommended)

   and placed first. If no interactive choice tool is available, fall back to a plain text list. Never ask iteratively ("which entity?" → user picks → "repository?" → …) when one batched call would do.
4. Context is fully empty for a critical input → ask plainly. This applies to: which entity (when not mentioned), the user's intent itself.

AskUserQuestion

AskUserQuestion

• Each call may contain up to 4 questions that are independent of each other (the tool will render them together). Use this to batch related decisions in one round-trip.
• Each question has 2–4 options. The tool auto-adds an "Other" choice for free-form input — never include it manually.
• Mark the recommended option by putting it first with

  (Recommended)

  appended to the label.

• header

  is a 12-char chip label (e.g. "Entity", "DTO mode", "Paths").
• Each option has a

  description

  explaining what the choice means.

AskUserQuestion

• Free-form input where there is no enumerable set of options (e.g. arbitrary class name, arbitrary path) — ask in plain text.
• The "single confirmation line" form from principle 2 — that is a plain question with an obvious yes/no, not an enumerated choice.

get_project_summary

language

bootMajor

moduleName

buildFile

mainPackage

list_module_dependencies(moduleName)

presentDeps

list_project_endpoints

endpoints

• list_all_domain_entities

  — needed only if the user did not name an entity in their prompt. Defer to Step 2 as a lazy fallback.

• list_entity_repositories

  — depends on knowing the entity, which happens in Step 2. Defer to Step 3 as a lazy fallback.

• get_entity_details

  — depends on knowing the entity. Defer to Step 2.

• list_entity_dtos

  /

  list_entity_mappers

  — depend on knowing the entity AND the DTO decision. Defer to Step 4.

get_project_summary

• language

  : Java or Kotlin

• bootMajor

  : 2, 3 or 4 (for jakarta vs javax, Jackson version)
• Check if

  org.springdoc:springdoc-openapi

  is in

  presentDeps

  -->

  hasSpringDoc

• Check if

  org.hibernate.validator:hibernate-validator

  or

  org.springframework.boot:spring-boot-starter-validation

  is in

  presentDeps

  -->

  hasValidation

• Jackson version detection: Check

  presentDeps

  for

  tools.jackson:jackson-databind

  or

  tools.jackson:jackson-core

  -->

  jacksonMajor = 3

  . Otherwise if

  com.fasterxml.jackson:jackson-databind

  -->

  jacksonMajor = 2

  . Spring Boot 4.x uses Jackson 3.x (

  tools.jackson

  package), Spring Boot 2.x/3.x use Jackson 2.x (

  com.fasterxml.jackson

  package).
  • If

    jacksonMajor = 3

    :

    JsonNodeFqn

    =

    tools.jackson.databind.JsonNode

    ,

    ObjectMapperFqn

    =

    tools.jackson.databind.ObjectMapper

  • If

    jacksonMajor = 2

    :

    JsonNodeFqn

    =

    com.fasterxml.jackson.databind.JsonNode

    ,

    ObjectMapperFqn

    =

    com.fasterxml.jackson.databind.ObjectMapper

• PagedModel detection:

  PagedModel

  (

  org.springframework.data.web.PagedModel

  ) is available in Spring Data 3.2+. If

  bootMajor >= 3

  (Spring Boot 3.2+) or

  bootMajor = 4

  , use

  PagedModel

  wrapper for GET_LIST with Page pagination. Otherwise return

  Page<Entity>

  directly.

get_project_summary

Product

list_all_domain_entities(moduleName)

entities

AskUserQuestion

list_all_domain_entities

get_entity_details(entityFqn)

• IdType

  -- entity ID field type (e.g.

  java.lang.Long

  ,

  java.util.UUID

  )

• entityVar

  -- decapitalized entity name (e.g.

  product

  )

• entityVarPlural

  -- pluralized decapitalized name (e.g.

  products

  )

• EntityName

  -- simple class name (e.g.

  Product

  )

• EntityNamePlural

  -- pluralized simple name (e.g.

  Products

  )
• Whether entity has validation annotations -->

  entityHasValidation

list_entity_repositories(entityFqn)

repos

• If exactly one repository exists → select it silently (principle 1).
• If the user named a specific repository → use it directly, skip the question.
• If multiple repositories exist → ask via

  AskUserQuestion

  with the options from

  repos

  .
• If no repository exists → inform the user and suggest creating one manually or using a separate skill.

• repoFieldName

  -- decapitalized repository class name (e.g.

  productRepository

  )

• RepoFqn

  -- FQN of repository class

list_entity_dtos(entityFqn)

list_entity_mappers(entityFqn)

• DtoFqn

  -- DTO class FQN

• dtoVar

  -- decapitalized DTO name

• mapperFieldName

  -- decapitalized mapper class name

• toDtoMethodName

  -- mapper method entity-->DTO (e.g.

  toDto

  )

• toEntityMethodName

  -- mapper method DTO-->entity (e.g.

  toEntity

  )

• updateMethodName

  -- mapper method for update (e.g.

  updateWithNullValues

  )

toEntity

updateWithNull

dto-creator

dto-creator

mapper-creator

mapper-creator

examples/_skeletons/java.md

examples/_skeletons/kotlin.md

language

• {packageName}

  --> controllerPackage

• {className}

  --> controllerName

• {requestPath}

  --> basePath + resourcePath

src/main/{java,kotlin}/{package-path}/{controllerName}.{java,kt}

selectedMethods

1. Determine the example file path:

   examples/_methods/{method-name}/{language}.md

2. Read the example file
3. Select the correct code variant based on:
   • DTO mode (no DTO vs with DTO)
   • For GET_LIST: pagination (PAGE / WINDOW / none) and filter (with/without)
   • For PATCH/PATCH_MANY: ObjectMapper vs ObjectPatcher, and DTO vs no-DTO (4 combinations)
   • For CREATE: with/without @Valid
4. Apply variable substitutions (ONLY variables declared in the Variables section)
5. FQN handling (CRITICAL): examples contain FQNs (e.g.

   org.springframework.web.bind.annotation.GetMapping

   ,

   org.springframework.data.domain.Pageable

   , entity/DTO/repository FQNs). When writing the final file, you MUST:
   1. Replace every FQN in the body with its short name
   2. Collect every FQN you shortened and emit a corresponding

      import

      line right after the

      package

      statement, sorted, no duplicates
   3. Classes from the same package as the controller must NOT be imported
   4. Types from

      java.lang

      must NOT be imported
   5. Kotlin: same rules — shorten in the body and add

      import

      lines at the top
6. Use Edit tool to insert the method into the controller class body

1. Read

   examples/_dependencies/dependencies.md

2. For each artifact NOT in

   presentDeps

   :
   • Use

     buildFile

     from Step 1
   • Edit the build file to add the dependency
3. Call

   refresh_build_system_model

4. No properties are written for this skill (controller has no application.properties entries)
5. Report: "Created controller {controllerName} with CRUD endpoints for {EntityName}. Added dependencies: [list]."

• The code comes from an examples/ file (cite which one)
• Only declared variables were substituted
• No framework API calls were added "from knowledge"
• Import list covers all FQNs shortened in the body (no missing imports, no extras)
• Method signatures match the example exactly
• No comments or convenience methods were added
• FQNs from examples are shortened in the body AND corresponding

  import

  lines were added after

  package

  (IDE will NOT do this for you)

• @ParameterObject

  annotation is only added when

  hasSpringDoc = true

• @Valid

  annotation is only added when

  hasValidation = true

  AND entity has validation annotations
• PATCH and PATCH_MANY methods use ObjectMapper (fallback) or ObjectPatcher depending on project dependencies
• getId() in PATCH_MANY matches entity's actual ID accessor
• Jackson FQNs use

  tools.jackson.databind.*

  for Jackson 3.x (Spring Boot 4.x) and

  com.fasterxml.jackson.databind.*

  for Jackson 2.x (Spring Boot 2.x/3.x). NEVER hardcode one or the other — always resolve

  ${JsonNodeFqn}

  and

  ${ObjectMapperFqn}

  from Step 1.
• GET_LIST with Page pagination uses

  PagedModel<Entity>

  wrapper (Spring Data 3.2+ / Boot 3.2+/4.x) or returns

  Page<Entity>

  directly (older versions). Select the correct example variant.