go-ddd

Define Go project architecture with Domain-Driven Design layers and bounded contexts.

Updated Apr 20, 2026
One-click install
npx skills add https://github.com/vincent119/ai-rules-kit --skill go-ddd
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: go-ddd
Source: https://github.com/vincent119/ai-rules-kit/tree/main/skills/go-ddd
Command: npx skills add https://github.com/vincent119/ai-rules-kit --skill go-ddd

SYSTEM DOCUMENTATION & REQUIREMENTS

Go projects often spiral into unmanageable complexity without a coherent architectural blueprint. This Skill defines a practical, Go-focused DDD blueprint that clearly delineates domains, boundaries, and layered responsibilities to improve maintainability and team autonomy.

Core Features & Use Cases

  • Clear, layered architecture: Domain, Application, Infrastructure, and Delivery layers with explicit responsibilities.
  • Bounded Context guidance: independent contexts, explicit inter-context communication via APIs or events, and guardrails to prevent cross-context leakage.
  • Practical project structure: recommended directory layout, sample artefacts, and migration paths to adopt quickly in new or existing projects.

Quick Start

Define and apply the blueprint to structure your Go project around DDD boundaries and layered architecture.

Frequently Asked Questions about go-ddd

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

FAQPage Schema
How do I structure a Go project using Domain-Driven Design principles?

Structure a Go DDD project by separating it into Domain, Application, Infrastructure, and Delivery layers. This blueprint defines clear domain boundaries and explicit responsibilities to improve maintainability and team autonomy.

What is the best way to isolate bounded contexts in a Go microservices architecture?

The best way to isolate bounded contexts in Go microservices is through explicit APIs or events. This architecture provides guardrails to prevent cross-context leakage and ensures independent contexts communicate without tight coupling.

Does this DDD blueprint work for both Go monoliths and microservices?

Yes, this DDD blueprint applies to both Go monoliths and microservices. It provides explicit domain models, modular boundaries, and dependency injection-friendly wiring to satisfy scalable application requirements.

How do I start adopting layered architecture in an existing Go application?

Start adopting layered architecture by following the provided practical project structure and migration paths. The blueprint offers a recommended directory layout and sample artefacts to quickly apply DDD boundaries to new or existing projects.

Why does my Go application need bounded contexts and domain boundaries?

Your Go application needs bounded contexts and domain boundaries to prevent spiraling into unmanageable complexity. A coherent architectural blueprint with explicit domain models ensures testable components and clear team autonomy.

Can I use dependency injection and testable components with this Go DDD architecture?

Yes, this Go DDD architecture is DI-friendly and designed for testable components. By clearly delineating domain, application, infrastructure, and delivery layers, the blueprint satisfies requirements for explicit domain models and modular wiring.