Skip to content
Skills Library
Programming · Planning

orthogonal-pattern-guide

/orthogonal-pattern-guide

Use when deciding how to decompose a system into modules or packages along independent variation axes, and where each concern's boundary belongs. Triggers on shared-core plus per-variant leaves, package-by-feature vs package-by-layer, sibling naming symmetry, parallel consumers that should mirror the same concepts, cross-axis constraints, cross-cutting concerns that are not axes, false modularity, or a module tree that feels tangled, even when the user doesn't say 'orthogonal'.

Repository
platform ↗
Licence
MIT
Last repository change
08.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
12
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 08.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when deciding how to decompose a system into modules or packages along independent variation axes, and where each concern's boundary belongs. Triggers on shared-core plus per-variant leaves, package-by-feature vs package-by-layer, sibling naming symmetry, parallel consumers that should mirror the same concepts, cross-axis constraints, cross-cutting concerns that are not axes, false modularity, or a module tree that feels tangled, even when the user doesn't say 'orthogonal'.

Triggers from the description

t say
Original author description

Use when deciding how to decompose a system into modules or packages along independent variation axes, and where each concern's boundary belongs. Triggers on shared-core plus per-variant leaves, package-by-feature vs package-by-layer, sibling naming symmetry, parallel consumers that should mirror the same concepts, cross-axis constraints, cross-cutting concerns that are not axes, false modularity, or a module tree that feels tangled, even when the user doesn't say 'orthogonal'.

How it works

  1. Essentials
  2. Handoffs
  3. Gotchas
  4. Progressive Disclosure
Original SKILL.md headings · 38 lines, 388 words
SKILL.md preview
---
name: orthogonal-pattern-guide
description: "Use when deciding how to decompose a system into modules or packages along independent variation axes, and where each concern's boundary belongs. Triggers on shared-core plus per-variant leaves, package-by-feature vs package-by-layer, sibling naming symmetry, parallel consumers that should mirror the same concepts, cross-axis constraints, cross-cutting concerns that are not axes, false modularity, or a module tree that feels tangled, even when the user doesn't say 'orthogonal'."
---

# Orthogonal Axes

Decompose around independent decisions likely to change. An axis names the question; each variant is one answer. A configuration chooses one variant per axis.

## Essentials

- **Find independent decisions**: derive axes from what can vary separately, not execution steps, see [references/finding-axes.md](references/finding-axes.md)
- **Separate commonality from variability**: keep only truly shared rules at the axis root and put each answer in a leaf, see [references/commonality-variability.md](references/commonality-variability.md)
- **Make the tree reveal the model**: use one directory per axis and bare, symmetric variant names, see [references/applying-the-layout.md](references/applying-the-layout.md), [references/naming-symmetry.md](references/naming-symmetry.md)
- **Localize cross-axis constraints**: place exceptional two-axis glue in the dependent variant, see [references/variation-point-bridges.md](references/variation-point-bridges.md)
- **Distinguish cross-cutting concerns**: apply concerns that touch every selection once around the composed operation, see [references/cross-cutting-concerns.md](references/cross-cutting-concerns.md)
- **Align ownership and change**: a change to one concept should stay inside one axis and one owner, see [references/boundary-alignment.md](references/boundary-alignment.md)

## Handoffs

- Use **hexagonal-pattern-guide** to design the ports and adapters that enforce a chosen axis.
- Use **microkernel-pattern-guide** to implement registration, discovery, capability gating, and binding time.
- Use **connascence-guide** to grade and loosen coupling across a proposed seam.
- Use **ddd-guide** to discover bounded contexts and domain vocabulary before drawing domain boundaries.

## Gotchas

- Two choices that always change together are one axis; splitting them creates permanent synchronization work.
- A concern present in every configuration is cross-cutting, not another selectable variant.
- Do not extract an axis for one hypothetical implementation. Wait for independent change pressure or a real second variant.
- A tidy tree is false modularity when leaves still import siblings or share hidden mutable state; enforce the dependency rules owned by **hexagonal-pattern-guide** and assess violations with **connascence-guide**.

## Progressive Disclosure

- Read [references/finding-axes.md](references/finding-axes.md) - Load when identifying variation points or deciding whether two concerns are one axis or two
- Read [references/commonality-variability.md](references/commonality-variability.md) - Load when splitting an axis root from its per-variant leaves
- Read [references/applying-the-layout.md](references/applying-the-layout.md) - Load when mapping axes onto a new tree or incrementally reorganizing a tangled one
- Read [references/naming-symmetry.md](references/naming-symmetry.md) - Load when naming axes, sibling variants, or parallel consumer structures
- Read [references/variation-point-bridges.md](references/variation-point-bridges.md) - Load when one variant has a genuine constraint involving another axis
- Read [references/cross-cutting-concerns.md](references/cross-cutting-concerns.md) - Load when logging, policy, telemetry, or another concern touches every variant
- Read [references/boundary-alignment.md](references/boundary-alignment.md) - Load when checking whether an axis follows one change concept and one owner
Files in this package (12)
  • SKILL.md 4 KB
  • SOURCES.md 6 KB
  • eval-queries.json 8 KB
  • evals.json 3 KB
  • moon.yml 1 KB
  • references/applying-the-layout.md 1 KB
  • references/boundary-alignment.md 1 KB
  • references/commonality-variability.md 1 KB
  • references/cross-cutting-concerns.md 1 KB
  • references/finding-axes.md 2 KB
  • references/naming-symmetry.md 1 KB
  • references/variation-point-bridges.md 1 KB

Versions

The database has no other skills named orthogonal-pattern-guide.

Database snapshot: 13.11.2026 · package version 0e4edcea8f30 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100lowy
    Volatility-based decomposition review. Trigger when: - Evaluating module boundaries against axes of change and business volatility. - Prompt contains: /lowy, volatility, axis of change, design decomposition, boundary.
  • 90module-boundaries
    Split modules along axes of change so things that change together live together and dependencies point one way. Use when a codebase groups by technical layer and every feature edit spans many folders.
  • 100go-packages
    Use when creating Go packages, organizing imports, managing dependencies, or deciding how to structure Go code into packages. Also use when starting a new Go project or splitting a growing codebase into packages, even if the user doesn't explicitly ask about package…
  • 100core-add-module
    Add a new module to the core package (src/packages/core/). Use when adding shared UI framework infrastructure that all packages can use — e.g., a new extension system feature, a new utility, a new shared component pattern, a new picker, or a new workspace primitive. Core modules…
  • 100module-design
    Foundational deep-module design operator and shared vocabulary. Use when designing or deepening a module's interface, deciding where a seam goes, partitioning orthogonal modules for concurrency, flattening if/else branching, making code, AI skills, or method systems more…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.