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.