project-context-ingestion

Map Kotlin and Spring repository configurations into a concise project brief.

14|1|Updated Mar 6, 2026
One-click install
npx skills add https://github.com/Kotlin/kotlin-backend-agent-skills --skill project-context-ingestion
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: project-context-ingestion
Source: https://github.com/Kotlin/kotlin-backend-agent-skills/tree/main/.agents/skills/project-context-ingestion
Command: npx skills add https://github.com/Kotlin/kotlin-backend-agent-skills --skill project-context-ingestion

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Inspects and builds an accurate mental model of a Kotlin + Spring repository before proposing code changes, ensuring alignment with modules, versions, and architectural constraints.

Core Features & Use Cases

  • Read and map project configuration (settings.gradle.kts, root and module build files, dependency catalogs, Gradle wrapper, and plugin usage) to capture versions, modules, and architecture boundaries.
  • Infer framework mode (MVC vs WebFlux), persistence approach, and test stack to guide safe recommendations.
  • Provide a concise, executable brief that can be used by downstream agents for architecture decisions and change planning.

Quick Start

Ask the agent to map the Kotlin/Spring repository to a compact project brief with architecture, version constraints, and module boundaries.

Frequently Asked Questions about project-context-ingestion

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I map a Kotlin Spring Boot repository architecture before making code changes?

To map a Kotlin Spring Boot repository, inspect Gradle settings, build files, and dependency catalogs to capture module boundaries, framework mode, and version constraints. This produces a concise project brief ensuring proposed code changes align with existing architectural constraints.

What's the best way to identify module boundaries and framework mode in a multi-module Gradle project?

Identify module boundaries and framework mode by reading root and module build files alongside the Gradle wrapper configuration. This maps multi-module project architecture, inferring MVC or WebFlux persistence approaches to guide safe, compatible recommendations across the technology stack.

Can I use this to capture Kotlin and Spring Boot version constraints across a multi-module project?

Yes, you can capture Kotlin and Spring Boot version constraints by reading settings.gradle.kts, dependency catalogs, and plugin usage. It records exact Gradle toolchain versions, framework modes, and plugins to verify technology stack consistency across all project modules.

How does repository context mapping infer persistence and test stack details?

Repository context mapping infers persistence and test stack details by analyzing dependency declarations and plugin configurations within Gradle build files. This mechanism extracts the persistence approach and testing frameworks to guide architecture decisions and ensure safe code modifications.

Do I need a Gradle wrapper to analyze my Kotlin Spring repository for architecture constraints?

You need a Gradle wrapper and standard build files like settings.gradle.kts to analyze a Kotlin Spring repository. Reading these configuration files captures toolchain versions, module structures, and dependency constraints required to produce an accurate architecture brief.

Why should I map repository context before planning changes to a Kotlin Spring project?

Map repository context before planning changes to avoid violating architectural boundaries and version constraints. It records framework mode, modules, and dependencies, ensuring downstream agents generate safe, compatible recommendations that align with the existing technology stack.