maister:context-distiller

Analyze domain descriptions to detect ambiguities and unsafe context generalizations.

40|39|Updated Apr 1, 2026
One-click install
npx skills add https://github.com/Architekt-Jutra/architekt-jutra-code --skill maister-context-distiller
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: maister:context-distiller
Source: https://github.com/Architekt-Jutra/architekt-jutra-code/tree/main/week7/4-uogolnienie-demo/context-distiller
Command: npx skills add https://github.com/Architekt-Jutra/architekt-jutra-code --skill maister-context-distiller

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the common domain-driven design challenge of ambiguous domain terminology, premature generalization leading to unmaintainable "God classes", and unnecessary splitting of bounded contexts that create avoidable complexity. It eliminates guesswork when deciding whether similar domain concepts can be safely unified or must remain separate in different contexts.

Core Features & Use Cases

  • Bidirectional linguistic analysis: Detects both ambiguities (same word meaning different things in different contexts) and generalization candidates (different words behaving identically in a specific context) to identify where contexts should split or merge.
  • Dual operation modes: Supports full domain distillation for end-to-end context mapping, and single concept probe mode for iterative analysis of individual suspected generalizations.
  • Safety guardrails: Includes fit tests to avoid unnecessary use, deep effect testing to prevent shallow generalization mistakes, and explicit boundary validation to avoid context leakage.
  • Use case example: For a training management domain with rooms, trainers, and equipment all requiring reservation, the Skill identifies that they can be generalized to a ReservableResource abstraction in the scheduling context, while keeping their specific models in HR (for trainer vacation) and maintenance (for equipment service) contexts.

Quick Start

Provide your full domain description, event storming output, or a single concept you suspect can be generalized to the context-distiller skill to receive a distilled context map with identified ambiguities, shared abstractions, and bounded context boundaries.

Frequently Asked Questions about maister:context-distiller

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

FAQPage Schema
How do I identify safe generalizations for bounded contexts in domain-driven design?

To identify safe generalizations in domain-driven design, apply bidirectional linguistic analysis to detect shared behavioral patterns across domain concepts. This reveals where similar concepts can be unified into generalized abstractions without creating unmaintainable God classes.

When should I split bounded contexts to avoid domain terminology ambiguity?

You should split bounded contexts when the same domain term means different things across different parts of the system. Linguistic analysis detects these cross-context ambiguities, ensuring specific context boundaries prevent domain terminology leakage and avoidable complexity.

What is the best way to map domain contexts from event storming output?

The best way to map domain contexts from event storming output is to run full domain distillation. This processes the entire domain description to produce a distilled context map with generalized abstractions, specific context boundaries, and safety notes.

How do I test if a domain concept generalization is safe before implementing it?

To test if a domain concept generalization is safe, use single concept probe mode to apply deep effect testing and explicit boundary validation. These safety guardrails prevent shallow generalization mistakes and unnecessary splitting of bounded contexts.

Can I design a microkernel architecture using distilled domain contexts?

Yes, you can design a microkernel and plugin-based domain architecture using distilled context maps. The maps provide generalized abstractions for the core and specific context boundaries for plugins, alongside safety notes to guide implementation.

Why does premature generalization create unmaintainable domain models?

Premature generalization creates unmaintainable domain models by forcing distinct domain concepts into broad abstractions like God classes. This ignores specific context boundaries and cross-context ambiguities, leading to shallow generalization mistakes and avoidable complexity.