ddd-implement

Generate a runnable Go hexagonal architecture application from bounded context definitions.

2|1|Updated Feb 4, 2026

Search Tags:#ddd #go #generator #bounded-context #hexagonal-architecture #ddd-implement

Ready to run

npx skills add https://github.com/jrlangford/ddd-companion --skill ddd-implement

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: ddd-implement
Source: https://github.com/jrlangford/ddd-companion/tree/main/skills/ddd-implement
Command: npx skills add https://github.com/jrlangford/ddd-companion --skill ddd-implement

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Transform BCR bounded context definitions into a walking skeleton: a runnable Go hexagonal architecture application with validated DDD boundaries. Use after completing the BCR workflow to generate implementation code and validate existing projects against DDD standards.

Core Features & Use Cases

Walking skeleton generation: create the end-to-end project structure (domain, ports, application, adapters, and mock) with wired wiring and runnable main.
Validation scaffolding: verify conformance to DDD patterns and manifest-driven progress, with optional TypeSpec/OpenAPI artifacts.
Multi-context orchestration: handle multiple bounded contexts in dependency order with checkpointing and session resumption.

Quick Start

Invoke the ddd-implement skill against your BCR workspace to bootstrap a production-shaped walking skeleton for your domain.

Frequently Asked Questions about ddd-implement

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

FAQPage Schema

How do I generate a Go walking skeleton from bounded context definitions?▼

To generate a Go walking skeleton from bounded context definitions, use this skill to transform your BCR workspace into a minimal, runnable hexagonal architecture application with validated DDD boundaries, wired wiring, and runnable main.

What is a walking skeleton in DDD and when do I need it?▼

A walking skeleton in DDD is a minimal, runnable application structure encompassing domain, ports, application, and adapters. You need it to validate end-to-end project architecture and DDD boundaries before implementing complex domain logic.

How do I validate an existing Go project against DDD standards and hexagonal architecture?▼

You validate an existing Go project against DDD standards by invoking this skill to verify conformance to DDD patterns, check manifest-driven progress, and validate bounded context boundaries within your hexagonal architecture setup.

Can I orchestrate multiple bounded contexts in dependency order with Go hexagonal architecture?▼

Yes, you can orchestrate multiple bounded contexts in dependency order. The skill handles multi-context orchestration automatically, providing checkpointing and session resumption to manage complex domain boundaries across your Go application.

Does the DDD walking skeleton generator support TypeSpec or OpenAPI artifacts?▼

Yes, the DDD walking skeleton generator supports optional TypeSpec and OpenAPI artifacts. It includes validation scaffolding that verifies DDD pattern conformance while generating these API specification artifacts alongside your Go code.