Claude Ddd Redesign

    2

    Domain-Driven Modernization: re-decompose N services into M bounded-context-aligned services with no unadjudicated behavioral change.

    $10

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    claude-ddd-redesign

    Example session with this skill installed

    I need to define a new modernization slice for the Billing service. Create the initial slice outline and size estimation artifacts based on Behaviors BHV-1021 and BHV-1022.

    • Read your context and instructions
    • Compiled the claude-ddd-redesign

    I have initialized the Slice Outline and Size estimation artifacts for the new Billing modernization slice. These files are grounded in the provided Behavior IDs and follow the Stage 3 schema requirements.

    Modernization Slice: SLC-0042 (Billing)

    slices/SLC-0042/slice.json

    {
      "id": "SLC-0042",
      "workstream": "WS-0005",
      "oracle_strategy": "characterization",
      "behaviors": ["BHV-1021", "BHV-1022"],
      "state": "draft"
    }
    

    slices/SLC-0042/size.json

    {
      "slice": "SLC-0042",
      "behaviors": 2,
      "interfaces_sync": 1,
      "interfaces_async": 0,
      "complexity_factors": [
        "cross-service-invariant-validation"
      ]
    }
    

    Next steps

    1. Review the behavior citations to ensure BHV-1021 and BHV-1022 cover all necessary billing invariants.
    2. Define the acceptance-criteria.json for this slice to map specific assertions to these behaviors.
    3. Update the roadmap.json to include this slice in the next delivery increment.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Modernizing legacy monoliths into distributed services often fails due to behavior drift and untraceable requirements. This skill package provides a rigorous, schema-driven framework for Domain-Driven Design (DDD) redesign, ensuring every service boundary is grounded in observed behavior rather than guesswork.

    What it does

    • Inventories behavior by extracting and classifying atomic facts from legacy code to maintain functional parity.
    • Models domains using strategic context maps and tactical aggregate models to define strict service boundaries.
    • Automates traceability by linking acceptance criteria and characterization tests directly to specific behavior IDs.
    • Manages migration through structured cutover plans, retirement registers, and multi-team migration waypoints.
    • Formalizes decisions using Architecture Decision Records (ADRs) and human-adjudicated consensus runs.

    How it works

    1. Initialize the inventory by running discovery agents to populate behavior.json and interfaces.json from the legacy source.
    2. Draft the model using contexts.json to define bounded contexts and divergences.json to flag conceptual conflicts between services.
    3. Sequence delivery by creating a roadmap.json that prioritizes the walking skeleton and manages capacity constraints.
    4. Define slices for incremental modernization, generating tactical-model.json and design.md for each deployable unit.
    5. Execute transition following the cutover-plan.json steps from shadow mode through to final decommissioning.

    Frameworks & tools

    This tool uses JSON Schema for all artifact validation. It integrates with Python-based linting scripts like trace-lint.py and resolve-identity.py.

    Why this beats prompting it yourself

    Generic prompts fail to maintain the strict traceability required for high-stakes refactoring. This skill enforces a schema-valid "spine" that connects legacy behavior to new implementation, preventing the silent loss of edge-case logic during service extraction.

    Use cases

    • Decomposing a monolithic Java or .NET application into Bounded Contexts.
    • Identifying and resolving domain logic divergences across different business units.
    • Managing long-running consumer migrations during interface retirement.
    • Generating a verifiable characterization suite for legacy system replacement.

    Known limitations

    Does not automate behavior extraction; relies on external discovery agents and manual review. Requires a human decider for all architectural adjudications.

    Requires human adjudication for all boundary decisions. Does not perform automated code extraction; operates on the metadata layer via provided JSON schemas.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Requires

    Python
    Git

    Permissions

    Terminal / Shell
    Read Files
    Browser
    Write Files
    Network Access
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill solves the 'black box' problem of legacy modernization by enforcing a schema-driven audit trail that links every new service boundary back to specific, documented legacy behaviors.

    The package includes a suite of JSON schemas for domain modeling, architectural decision templates (ADRs), and specialized Python-based scripts like `trace-lint.py` for validating your transformation plan.

    While it works best with Claude 3.5 Sonnet or Opus due to the complex reasoning required, the framework is compatible with any high-context window AI agent capable of processing structured JSON and Python scripts.

    No, this skill is designed for human-in-the-loop architecture; it provides the structure and validation, but requires an architect to adjudicate conceptual conflicts and review discovery agent outputs.

    Setup involves initializing a local workspace with the provided JSON schemas and running the discovery agents to populate your initial behavior inventory, typically taking less than 30 minutes.

    The skill is designed to handle complex logic in any language (Java, .NET, Python, etc.), as it operates on extracted behaviors and interfaces rather than performing direct transpilation.

    New in Agents & Orchestration