architecture-domain-analysis

Analyzes codebases to classify subdomains and map them to bounded contexts using DDD principles.

Updated Jan 9, 2025
One-click install
npx skills add https://github.com/baotoq/go-shortener --skill architecture-domain-analysis
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-domain-analysis
Source: https://github.com/baotoq/go-shortener/tree/main/.agents/skills/architecture-domain-analysis
Command: npx skills add https://github.com/baotoq/go-shortener --skill architecture-domain-analysis

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill helps you understand the complex relationships within a codebase by identifying distinct business domains, classifying them (Core, Supporting, Generic), and suggesting clear boundaries for Bounded Contexts, leading to better system design and maintainability.

Core Features & Use Cases

  • Subdomain Identification: Classifies parts of your system as Core (competitive advantage), Supporting (business-specific), or Generic (outsourcable).
  • Bounded Context Mapping: Suggests explicit linguistic boundaries for your domains.
  • Cohesion Analysis: Assesses how well concepts within a domain fit together.
  • Use Case: When refactoring a monolithic application, use this Skill to identify natural seams for creating microservices based on business capabilities, rather than technical layers.

Quick Start

Analyze the provided codebase to identify its core, supporting, and generic subdomains and map them to bounded contexts.

Frequently Asked Questions about architecture-domain-analysis

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

FAQPage Schema
How do I identify bounded contexts in a monolithic codebase for microservices?

To identify bounded contexts in a monolith, analyze the codebase to group concepts by ubiquitous language and assess domain cohesion. This process detects natural linguistic boundaries and low cohesion issues, suggesting clear seams for decomposing the application.

What is the difference between core, supporting, and generic subdomains in DDD?

In Domain-Driven Design, core subdomains provide competitive advantage, supporting subdomains are business-specific but not differentiating, and generic subdomains are outsourcable. Analyzing your codebase classifies these parts to prioritize architectural focus and maintainability.

How do I assess domain cohesion when refactoring code?

You assess domain cohesion by analyzing how well extracted concepts like entities, services, and use cases fit together within a specific domain. This analysis detects low cohesion issues and suggests clear integration patterns to enforce boundaries.

Can I use DDD principles to split my application based on business capabilities?

Yes, you can apply Domain-Driven Design principles to split an application based on business capabilities. By classifying subdomains and mapping them to bounded contexts, you refactor along natural seams rather than technical layers.

When do I need bounded context mapping for my system design?

You need bounded context mapping when complex relationships within a codebase obscure system design. It helps you understand distinct business domains by suggesting explicit linguistic boundaries, leading to better maintainability.