lowy

Identifies axes of change in modules using volatility-based decomposition.

25|2|Updated Apr 3, 2026
One-click install
npx skills add https://github.com/srid/agency --skill lowy
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: lowy
Source: https://github.com/srid/agency/tree/main/.apm/skills/lowy
Command: npx skills add https://github.com/srid/agency --skill lowy

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Evaluate architecture and module boundaries using Juval Lowy's volatility-based decomposition to ensure boundaries encapsulate axes of change behind stable interfaces.

Core Features & Use Cases

  • Identify sequence volatility vs activity volatility to guide boundary placement.
  • Evaluate and name boundaries based on the volatility they encapsulate, reducing blast radius.
  • Provide practical guidance when reviewing decompositions, services, and abstractions in codebases of various sizes.

Quick Start

Determine the axes of change in a module and apply Lowy's framework to decide if a boundary isolates volatility behind a stable interface.

Frequently Asked Questions about lowy

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

FAQPage Schema
What is volatility-based decomposition in software architecture?

Volatility-based decomposition is an architectural design method that identifies axes of change and encapsulates them behind stable module boundaries to reduce blast radius. It distinguishes sequence volatility from activity volatility to guide boundary placement.

How do I identify axes of change to guide module boundary placement?

To identify axes of change, analyze your codebase for sequence volatility and activity volatility, then name boundaries based on the specific volatility they encapsulate. This ensures module interfaces remain stable while isolating internal fluctuations.

Can I use volatility-based decomposition for architectural reviews in large codebases?

Yes, volatility-based decomposition suits architectural reviews of module and service boundaries across codebases of varying sizes and team structures. It evaluates existing decompositions to ensure abstractions properly isolate volatility.

What is the difference between sequence volatility and activity volatility when evaluating module boundaries?

Sequence volatility refers to changes in the order of operations, while activity volatility involves changes to the operations themselves. Evaluating both helps determine optimal boundary placement to encapsulate distinct rates of change.

How do I ensure stable interfaces when encapsulating change in service boundaries?

Ensure stable interfaces by explicitly naming the axis of volatility a boundary encapsulates and verifying that internal changes do not propagate outward. This keeps service contracts stable while managing internal fluctuations.

When should I not use volatility-based decomposition for my service architecture?

Avoid volatility-based decomposition when axes of change cannot be clearly identified or when module boundaries do not require strict volatility isolation. It provides the most value during structural reviews where reducing blast radius is critical.