domain-decomposition-api-design-advisor

Derive domain boundaries and API contracts for Kotlin + Spring systems.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Decompose business scope into explicit technical boundaries and contracts to prevent drift during implementation, align ownership, and improve change resilience.

Core Features & Use Cases

  • Convert vague product intent into well-scoped domains, boundaries, and API contracts.
  • Identify aggregates, ownership, data boundaries, and failure handling to guide architecture decisions.
  • Use ADR-style reasoning to document tradeoffs and rationale for Kotlin + Spring systems.

Quick Start

Propose domain boundaries and API contracts for a new feature in a Kotlin + Spring project.

Frequently Asked Questions about domain-decomposition-api-design-advisor

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

FAQPage Schema
How do I define domain boundaries and API contracts for a Kotlin Spring project?

To define domain boundaries and API contracts in a Kotlin Spring project, you decompose business scope into explicit technical boundaries. This process maps bounded contexts, ownership, and failure handling to prevent implementation drift and align ownership.

What is domain decomposition and when do I need it for API design?

Domain decomposition is the process of converting vague product intent into well-scoped domains, boundaries, and API contracts. You need it when shaping a new feature, service, or major redesign to prevent technical drift and improve change resilience.

How do I document architecture tradeoffs for bounded contexts using ADRs?

You document architecture tradeoffs for bounded contexts using Architecture Decision Records (ADRs) to capture rationale. This approach outlines the problem framing, proposed boundaries, consistency map, and tradeoffs to guide architecture decisions in your system.

Can I use domain decomposition to identify aggregates and data ownership?

Yes, applying the domain decomposition approach allows you to identify aggregates, ownership, data boundaries, and failure handling. This explicit mapping ensures that architecture decisions are grounded in clear technical boundaries and structured models.

Does this approach work for redesigning existing features in a Spring codebase?

Yes, applying domain decomposition works effectively for redesigning existing features in a Spring codebase. It clarifies domain boundaries and API contracts first, ensuring that ownership and consistency maps are explicitly defined to improve change resilience.

What is the best way to prevent implementation drift when decomposing a domain?

The best way to prevent implementation drift when decomposing a domain is to establish explicit API contracts and technical boundaries early. Mapping data ownership and failure handling ensures alignment and delivers a structured model including tradeoffs and an ADR outline.