domain-modeling

Design domain models that parse YAML, JSON, or Markdown into typed objects.

Updated Jan 25, 2026
One-click install
npx skills add https://github.com/gestrich/python-architecture --skill domain-modeling-gestrich
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: domain-modeling
Source: https://github.com/gestrich/python-architecture/tree/main/plugin/skills/domain-modeling
Command: npx skills add https://github.com/gestrich/python-architecture --skill domain-modeling-gestrich

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Domain modeling often leads to scattered parsing logic, weak type-safety, and duplicated validation. This skill provides a structured approach to create rich domain models that parse data once and expose type-safe APIs, promoting reuse across services.

Core Features & Use Cases

  • Parse-Once Pattern: Convert raw data (YAML, JSON, Markdown) into well-formed domain models and expose typed accessors.
  • Boundary-driven Architecture: Use the Repository pattern to fetch raw data and construct domain models at the boundary.
  • Factory Methods & Type Safety: Provide factory methods like from_yaml_string to validate and create strongly-typed domain objects.
  • Testability & Reuse: Domain models can be tested independently and reused across multiple services.

Quick Start

  • Create a simple domain model (Project) with a factory method from_yaml_string(project, content) to parse YAML into typed objects.
  • Load configuration for a given project via a Repository and access reviewers with config.reviewers.

Frequently Asked Questions about domain-modeling

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

FAQPage Schema
How do I centralize domain model parsing and validation for reuse across multiple services?

Centralize domain model parsing by applying the parse-once pattern to convert raw data into typed objects at the boundary, exposing type-safe APIs for reuse across multiple services without duplicating validation logic.

What is the best way to implement a Repository pattern for parsing YAML configurations into typed objects?

Implement a Repository pattern by fetching raw YAML data and constructing domain models at the boundary using factory methods like from_yaml_string, ensuring parsing happens once and yields strongly typed objects.

How do I create type-safe domain models from raw JSON or Markdown data?

Create type-safe domain models from raw JSON or Markdown by using factory methods to validate data and construct strongly typed objects, enforcing boundary validation and clear separation of concerns through a dedicated domain layer.

When do I need the parse-once pattern in my software architecture?

You need the parse-once pattern when domain modeling leads to scattered parsing logic, weak type-safety, and duplicated validation, allowing you to convert raw data into well-formed models and expose typed accessors.

Does this domain modeling approach support independent testability for configuration objects?

Yes, this domain modeling approach supports independent testability by creating rich domain models that parse data once, allowing configuration objects to be tested independently and reused across multiple services.

How do I separate parsing logic from business logic when loading project configurations?

Separate parsing logic from business logic by using a Repository to fetch raw data and factory methods to construct domain models at the boundary, centralizing validation in a dedicated domain layer with type-safe accessors.