domain-decomposition-api-design-advisor

Decompose business scope into bounded contexts and API contracts for Kotlin and Spring projects.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Decompose business scope into bounded contexts, module or service boundaries, workflows, and API contracts before implementation begins. Use when shaping a new feature, service, or major redesign; when requirements are underspecified; when consistency, idempotency, and integration boundaries must be made explicit; or when ADR-quality tradeoff reasoning is needed for Kotlin plus Spring systems.

Core Features & Use Cases

  • Define domain boundaries and responsibilities using ADR-style decisions.
  • Produce API contracts and data ownership mappings before implementation.
  • Provide a structured workflow to break down features into use cases and state transitions.
  • Ensure explicit invariants, idempotency, and clear failure handling.

Quick Start

Begin by identifying the feature's use cases, boundaries, and ownership, then capture the ADR-style decisions in your project documentation.

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 decompose business scope into bounded contexts before implementation?

Decompose business scope by defining domain boundaries, responsibilities, and API contracts using ADR-style decisions. This structured workflow breaks down features into use cases and state transitions, ensuring explicit invariants and clear data ownership before coding begins.

What's the best way to design API contracts for Kotlin and Spring projects?

Design API contracts for Kotlin and Spring projects by mapping data ownership and defining explicit invariants, idempotency, and failure handling. ADR-style decision documentation captures tradeoff reasoning to ensure consistency and clear integration boundaries across modules.

When do I need to define domain boundaries and module ownership?

Define domain boundaries when shaping a new feature, service, or major redesign. You need explicit boundaries when requirements are underspecified, or when consistency, idempotency, and integration boundaries must be clearly established before implementation.

Can I use ADR-style decisions to manage underspecified requirements?

Yes, ADR-style decisions manage underspecified requirements by capturing tradeoff reasoning and explicit invariants. This approach structures feature breakdown into use cases and state transitions while documenting clear ownership for Kotlin and Spring systems.

Does domain decomposition help with redesigns and state transitions?

Domain decomposition helps with redesigns by providing a structured workflow to break down features into use cases and state transitions. It ensures explicit invariants, idempotency, and clear failure handling are defined before implementation in Kotlin and Spring projects.