[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6WWABC3V41GVRB4Z13T54NJ":3,"skill-same:01M6WWABC3V41GVRB4Z13T54NJ":81},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":28,"publishedAt":49,"linkOnly":50,"markdownContent":51,"markdownBody":52,"frontMatter":53,"refName":54,"commitSha":55,"skillDirectory":56,"forksCount":14,"repositoryHtmlUrl":57,"repositoryHomepageUrl":6,"ownerHtmlUrl":58,"ownerBlogUrl":59,"ownerDescription":6,"updatedAt":60,"install":61,"resources":74},"01M6WWABC3V41GVRB4Z13T54NJ","righting-software",null,"Juval Löwy's \"The Method\" (Righting Software, 2019) as an operating procedure. Decompose a system by axes of volatility, never by functionality; classify components into the fixed taxonomy (Client, Manager, Engine, ResourceAccess, Resource, Utilities); validate by call chains; then design the project that builds it. Use when the user asks for system design, architecture review, service decomposition, \"The Method\", volatility-based decomposition, or asks how long\u002Fcostly a build will be.","zero8urn\u002Fagentic-goo","zero8urn","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F3292107?v=4","01M6MYMR6FG7W189TD21HH43N7","BDB","01M6MYMRAGFZ28K696F7PP93ZJ",0,"MIT","https:\u002F\u002Fgithub.com\u002Fzero8urn\u002Fagentic-goo\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Frighting-software\u002FSKILL.md",[18,23],{"categoryNo":19,"categoryName":20,"taxonomyType":21,"taxonomyTypeDesc":22},"01JBSEEDCAT000000000000015","视觉设计","SCENARIO","使用场景",{"categoryNo":24,"categoryName":25,"taxonomyType":26,"taxonomyTypeDesc":27},"01JBSEEDCAT000000000000032","设计师","PROFESSION","适用职业",[29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48],"righting software","software","system design","when","for","operating","long","as","project","call","design","decompose","never","use","system","taxonomy","Volatility","architecture review","architecture","components","2026-11-10 10:12:30",false,"---\nname: righting-software\ndescription: Juval Löwy's \"The Method\" (Righting Software, 2019) as an operating procedure. Decompose a system by axes of volatility, never by functionality; classify components into the fixed taxonomy (Client, Manager, Engine, ResourceAccess, Resource, Utilities); validate by call chains; then design the project that builds it. Use when the user asks for system design, architecture review, service decomposition, \"The Method\", volatility-based decomposition, or asks how long\u002Fcostly a build will be.\n---\n\n# Righting Software (The Method)\n\nThe Method is two formulas: **system design** + **project design**. The architecture is a means\nto an end — the end is a defensible answer to \"how long will it take and how much will it cost\".\n\nThe Prime Directive, from which almost everything else follows:\n\n> **Never design against the requirements.** Design the smallest set of components that can be\n> composed to satisfy present and future, known and unknown requirements. When the requirements\n> change and your design changes with them, the design added no value.\n\nA component is justified only by the **volatility it encapsulates**. If you cannot name the axis of\nchange a component absorbs, it must not exist.\n\n---\n\n## 1. The two forbidden decompositions\n\nThese are the failure modes the skill exists to catch. They are also the most natural things to do,\nwhich is why they win.\n\n| | What it is | Why it fails |\n|---|---|---|\n| **Functional decomposition** | One component per required functionality (Invoicing, Billing, Shipping); components named after steps in a use case | Couples the architecture to the requirements. Change is by definition not in one place. Produces either an explosion of tiny services or god-monoliths, often both side by side. Precludes reuse — lift B and A and C hang off it. Forces the client to orchestrate, so the client becomes the system. Multiple points of entry for security, scaling, transactions. Untestable: defects live in the interactions, not the units. |\n| **Domain decomposition** | One component per business domain (Sales, Accounting, Kitchen) | Functional decomposition in disguise. Behaviours that cross domains have nowhere to live; cross-domain communication degrades to CRUD. Each domain becomes an ugly grab bag. |\n\n**Test for functional decomposition:** can you state the axis of volatility the component\nencapsulates in one sentence? If the answer is \"it does X\", it is functional.\n\n**Anti-design check.** When a team insists its design is fine, run the contest: half the team\nproduces the best design, half produces the design that maximises future pain. Compare. They are\nusually the same design, with different labels.\n\n---\n\n## 2. Volatility, not variability\n\nTwo axes, and they are independent:\n\n1. **Time** — for the *same* customer, what can change over time?\n2. **Customers** — with time frozen, what differs *across* customers?\n\nRules:\n\n- **Volatility is not variability.** Something handleable with an `if`\u002F`else`, a flag, or a config\n  value is variability, not volatility. Variability is a parameter; volatility is a boundary.\n- **Watch for solutions masquerading as requirements.** \"The system must use a message bus\" is a\n  solution. Ask what could change, then decide whether a component is the right container.\n- **Design for your competitor** (or another division of your company). The things you do\n  differently are volatility. The things that are the *nature of the business* are not — and the\n  nature of the business is almost never volatile. Encapsulating it is the speculating-design trap.\n- **Anything absent from the volatility list is assumed not volatile enough to need a component.**\n  Call out volatilities early: designating a component costs nothing now, and buys effort later.\n- **Volatility decreases top-down; reuse increases top-down.** Clients are the most volatile,\n  Resources the least. If the components you depend on most are also the most volatile, the system\n  will implode.\n\n---\n\n## 3. The taxonomy (fixed — do not invent categories)\n\nEvery code unit belongs to exactly one category. If you cannot decide which, the unit is wrong.\n\n| Category | Answers | Encapsulates | Notes |\n|---|---|---|---|\n| **Client** | *Who* interacts | Client technology, presentation, protocol, channel | A user or another system. Must not contain business logic. Single point of entry. |\n| **Manager** | *What* is required | Volatility in the **sequence** of activities (workflow, use case) | One Manager = a family of related use cases. Holds transient workflow state only. |\n| **Engine** | *How* the business logic runs | Volatility in a **single activity** (rules, formulas, policy) | Stateless. Strategy pattern. Shared across Managers. |\n| **ResourceAccess** | *How* the system reaches data | Data-access technology | The only component allowed to touch a Resource. Exposes atomic business verbs, not CRUD. |\n| **Resource** | *Where* state lives | Storage\u002Fvendor\u002Fschema | Passive. Calls nothing. No business logic in schemas, triggers, or stored procedures. |\n| **Utilities** | Cross-cutting | Infrastructure | Security, Logging, Diagnostics, Hosting, Configuration, Localization, Pub\u002FSub bus, Identity. Callable from any layer. No business logic. |\n\nNaming: `\u003CNounOfVolatility>Manager`, `\u003CGerund>Engine`, `\u003CNounOfResource>Access`. Atomic business\nverbs belong on **operations**, never on service names. `PricingEngine` beats `OrderService` when\npricing is the volatility boundary.\n\n**The four questions are also the validation pass.** After the design, re-ask them: is every Client\npure *who*, with no trace of *what*? Is every Manager free of *who* and *where*? Overlap is a red\nflag — unless you can still defend the encapsulation, in which case keep it.\n\n---\n\n## 4. Communication rules (closed architecture)\n\nClosed architecture trades flexibility for encapsulation. These are the sanctioned relaxations, not\na licence to improvise:\n\n1. Clients call **Managers only**. A Client must not call multiple Managers in one use case.\n2. Managers call **Engines and ResourceAccess**, and any Utility.\n3. Manager → Manager is **queued only** (pub\u002Fsub through the bus). Never synchronous.\n4. Engines never call Engines. Engines never call ResourceAccess. The Manager pulls, then passes in.\n5. Nothing calls upward. Engines and ResourceAccess never call Clients.\n6. ResourceAccess is the only path to a Resource. No ORM call in a Manager, no raw SQL in an Engine.\n7. Never queue calls to Engines or ResourceAccess. Engines and ResourceAccess do not publish or\n   subscribe to events.\n8. Between layers pass primitives, arrays of primitives, data contracts, arrays of data contracts.\n   Logic behind a data contract does not cross a layer. Passing \"entities\" breaks encapsulation.\n9. **Strive for symmetry.** Use cases that call in different shapes signal a design problem worth\n   investigating.\n10. When you feel you must \"open up\" the architecture, that is a signal you need pub\u002Fsub or\n    queuing — not a licence to break the rule. Name the underlying need; do not dismiss the\n    transgression.\n\nSubsystems: group Managers, Engines, and ResourceAccess into a cohesive slice. **Max 3 Managers per\nsubsystem.** A component inside a subsystem cannot be released alone — release one subsystem at a\ntime. Do not assume each slice is a microservice; a microservice may be a group of slices.\n\n**Golden ratio (Manager : Engine).** 1:(0 or 1), 2:1, 3:2, 5:3. As Managers grow, the need for\nEngines grows at a decelerating rate. Many Managers relative to Engines means you decomposed by\nfunction. Redesign. Order of magnitude for a whole system is ~10 components, not hundreds.\n\n---\n\n## 5. Workflow\n\n1. **Vision → objectives → mission.** Write the vision as a single sentence, legal-grade. Objectives\n   that do not serve the vision are cut. The mission states how the work is executed. This hierarchy\n   outranks architecture in argument; it is how you refuse irrelevant demands.\n2. **Use cases.** Separate **core use cases** (the essence of the business — the ones that do not\n   change unless the nature of the business changes) from the fluff (happy, sad, incomplete paths).\n   Use activity diagrams with swim lanes, not flowcharts.\n3. **Volatility list.** Work both axes. Mark each entry volatile or variable. Flag any entry that is\n   really a solution.\n4. **Map volatilities to components.** Rarely 1:1 — one component may absorb several volatilities,\n   some map to an operational concept or a third-party component. Classify each into the taxonomy.\n5. **Validate by call chains.** Take the top 4–6 distinct use cases and show them as interactions\n   between the minimal set of components. Iterate the factoring until every conceivable use case is\n   satisfiable by composition. **Any component that appears in no call chain is unnecessary.**\n6. **Check the shape.** Golden ratio, volatility decreasing top-down, reuse increasing top-down,\n   symmetry across call chains, ≤3 Managers per subsystem.\n7. **Allocation.** Assemblies, hosts\u002Fprocesses (layer boundary is usually process boundary; Engines\n   and ResourceAccess run in-proc to a Manager), identities (minimise; trusted subsystem pattern —\n   each layer authenticates its immediate caller), authentication\u002Fauthorization boundaries,\n   transactions (start as far upstream as possible, engulf as much as possible, keep under 1 second),\n   and logical threads of execution — any reentrant cyclic path means deadlock or a design error.\n8. **Project design** (§6) — only after the architecture exists.\n\n---\n\n## 6. Project design (the second half)\n\nProject design is the assembly instruction. It derives from the architecture, not from optimism.\n\n- **Core team** = project manager + product manager + architect, three roles, three people, present\n  for the whole project. The architect owns both the system design and the project design. One\n  architect for design integrity. **One developer per service, 1:1** — anything else cannot be\n  estimated reliably.\n- **Fuzzy front end** is 15–25% of project duration. Nothing is committed before cost, schedule, and\n  risk exist.\n- **Estimates are accurate, not precise.** Quantum of 5 days. Itemise the full lifecycle of every\n  service: learning curve, test client, installation, integration points, peer review, documentation.\n  PERT: `E = (T + 4M + P) \u002F 6`.\n- **Critical path** = longest path through the activity network = the duration of the project. No\n  project can be accelerated beyond it. Assign the best resources to the critical path first;\n  accelerating non-critical paths accelerates nothing.\n- **Floats are the project's safety margin and its risk meter.** Low float = high risk. Trade float\n  for resources deliberately.\n- **Risk index** (normalised 0–1): `Risk = (4C + 3R + 2Y + 1G) \u002F (4N)` over critical\u002Fred\u002Fyellow\u002Fgreen\n  activities. Acceptable band 0.3–0.75; decompress toward **0.5**. Crossover ≈ 0.75. Subcritical\n  staffing pushes risk to ~0.9 and costs at least 25% more for 35% longer — there is no saving.\n- **Present several options**, not one plan: cheapest, fastest, safest, best combination. Points above\n  the time-cost curve are feasible; points below it are impossible — a project committed below the\n  curve has already failed.\n- **God activities** (oversized, placeholder for uncertainty) must be broken up or factored out as\n  separate projects; they distort the whole risk calculation.\n\n---\n\n## 7. Output artifact\n\nWrite the design as a document with these sections, in order. Template:\n`assets\u002Fdesign_doc_template.md`.\n\n1. Vision, objectives, mission\n2. Core use cases (and the fluff, listed but not load-bearing)\n3. Volatility list — two axes, each entry marked volatile \u002F variable \u002F solution-in-disguise\n4. Component table — name, category, **the single axis of volatility it encapsulates**, what it calls\n5. Call chains for the top 4–6 use cases\n6. Allocation — assemblies, processes, identities, auth boundaries, transactions\n7. **Unassigned volatilities** and **components in no call chain** — see §8\n8. Project design options — duration, cost, risk index per option\n\n---\n\n## 8. The section that catches the gap\n\nTwo checks must be run against the actual document, not from memory, and reported plainly:\n\n- **Every volatility in §3 has an owner.** A volatility with no component is an assumption that the\n  change will never happen.\n- **Every component is in at least one call chain.** A component in no call chain is decoration.\n\nThen state whether the design is currently *validatable*: can the core use cases be walked as call\nchains with the components that exist in the document? If not, say so. A design document that lists\ncomponents it never uses reads as complete and is not.\n\n---\n\n## 9. Gotchas\n\n- **The allure is the problem.** Functional decomposition looks free. Design that costs no effort\n  adds no value — there is no free lunch. If a decomposition could be done by a tool, it is not\n  design.\n- **Volatility is not self-evident.** It takes longer than functional decomposition, and it fights\n  management. The Dunning–Kruger effect is the default state: people who cannot see the volatilities\n  are also the people most confident their decomposition is right.\n- **Do not design against the requirements** even when the deadline demands it. The deadline is paid\n  for in multiples later.\n- **Unit testing is the streetlight effect.** It is necessary and nearly useless on its own: defects\n  live in the interactions between units, and changing one unit invalidates the others. Regression\n  testing of interactions is the real check.\n- **The Method is not a silver bullet.** It does not remove creativity, responsibility for getting\n  the use cases right, or liability for getting it wrong. It mechanises the decisions so the crunch\n  is spent on judgment, not on enumeration.\n- **Time crunch is load-bearing.** 3–5 days, top 4–6 use cases, ~40–60 diagrams. Without the crunch\n  you get analysis-paralysis and gold-plating.\n- **Boxes and arrows communicate only so much.** Non-obvious decisions must be written down, with the\n  tradeoff that produced them.\n- **Do not mix architectures.** The taxonomy is the only one allowed in the system. Do not blend it\n  with DDD aggregates, Clean Architecture use-case layers, hexagonal ports, onion shells, or vertical\n  slices. If a hybrid is required, the volatility was mis-identified — fix that instead.\n\n---\n\n## 10. Routing\n\nRoutes here for: system design, architecture review, service decomposition, \"is this decomposition\nright?\", naming a component, validating a design against use cases, and the schedule\u002Fcost\u002Frisk\nquestion for a build.\n\nDoes **not** route here for: implementation (design authority is not build authority), detailed\ndesign — interfaces, class hierarchies, and idioms are below The Method and can change without\ntouching the decomposition — coding-style review, or technology selection.\n\nThe Method mechanises design decisions. It does not make the decisions. Every component in the output\nmust trace to a named volatility; a component with no volatility is reintroduced assumption.\n\n---\n\n## Changelog\n\n- v1.0.0 (2026-11-07) — Initial skill. Prime Directive, the two forbidden decompositions,\n  volatile-vs-variable, the two axes, the fixed taxonomy and the four questions, closed-architecture\n  communication rules, golden ratio and subsystem caps, call-chain validation, the mandatory\n  unassigned-volatility \u002F no-call-chain check, and the project-design half (core team, critical path,\n  floats, risk index, options). Distilled from the book's chapters 2–4 plus Löwy's SDD 2022 deck and\n  the InfoQ author interview.\n","# Righting Software (The Method)\n\nThe Method is two formulas: **system design** + **project design**. The architecture is a means\nto an end — the end is a defensible answer to \"how long will it take and how much will it cost\".\n\nThe Prime Directive, from which almost everything else follows:\n\n> **Never design against the requirements.** Design the smallest set of components that can be\n> composed to satisfy present and future, known and unknown requirements. When the requirements\n> change and your design changes with them, the design added no value.\n\nA component is justified only by the **volatility it encapsulates**. If you cannot name the axis of\nchange a component absorbs, it must not exist.\n\n---\n\n## 1. The two forbidden decompositions\n\nThese are the failure modes the skill exists to catch. They are also the most natural things to do,\nwhich is why they win.\n\n| | What it is | Why it fails |\n|---|---|---|\n| **Functional decomposition** | One component per required functionality (Invoicing, Billing, Shipping); components named after steps in a use case | Couples the architecture to the requirements. Change is by definition not in one place. Produces either an explosion of tiny services or god-monoliths, often both side by side. Precludes reuse — lift B and A and C hang off it. Forces the client to orchestrate, so the client becomes the system. Multiple points of entry for security, scaling, transactions. Untestable: defects live in the interactions, not the units. |\n| **Domain decomposition** | One component per business domain (Sales, Accounting, Kitchen) | Functional decomposition in disguise. Behaviours that cross domains have nowhere to live; cross-domain communication degrades to CRUD. Each domain becomes an ugly grab bag. |\n\n**Test for functional decomposition:** can you state the axis of volatility the component\nencapsulates in one sentence? If the answer is \"it does X\", it is functional.\n\n**Anti-design check.** When a team insists its design is fine, run the contest: half the team\nproduces the best design, half produces the design that maximises future pain. Compare. They are\nusually the same design, with different labels.\n\n---\n\n## 2. Volatility, not variability\n\nTwo axes, and they are independent:\n\n1. **Time** — for the *same* customer, what can change over time?\n2. **Customers** — with time frozen, what differs *across* customers?\n\nRules:\n\n- **Volatility is not variability.** Something handleable with an `if`\u002F`else`, a flag, or a config\n  value is variability, not volatility. Variability is a parameter; volatility is a boundary.\n- **Watch for solutions masquerading as requirements.** \"The system must use a message bus\" is a\n  solution. Ask what could change, then decide whether a component is the right container.\n- **Design for your competitor** (or another division of your company). The things you do\n  differently are volatility. The things that are the *nature of the business* are not — and the\n  nature of the business is almost never volatile. Encapsulating it is the speculating-design trap.\n- **Anything absent from the volatility list is assumed not volatile enough to need a component.**\n  Call out volatilities early: designating a component costs nothing now, and buys effort later.\n- **Volatility decreases top-down; reuse increases top-down.** Clients are the most volatile,\n  Resources the least. If the components you depend on most are also the most volatile, the system\n  will implode.\n\n---\n\n## 3. The taxonomy (fixed — do not invent categories)\n\nEvery code unit belongs to exactly one category. If you cannot decide which, the unit is wrong.\n\n| Category | Answers | Encapsulates | Notes |\n|---|---|---|---|\n| **Client** | *Who* interacts | Client technology, presentation, protocol, channel | A user or another system. Must not contain business logic. Single point of entry. |\n| **Manager** | *What* is required | Volatility in the **sequence** of activities (workflow, use case) | One Manager = a family of related use cases. Holds transient workflow state only. |\n| **Engine** | *How* the business logic runs | Volatility in a **single activity** (rules, formulas, policy) | Stateless. Strategy pattern. Shared across Managers. |\n| **ResourceAccess** | *How* the system reaches data | Data-access technology | The only component allowed to touch a Resource. Exposes atomic business verbs, not CRUD. |\n| **Resource** | *Where* state lives | Storage\u002Fvendor\u002Fschema | Passive. Calls nothing. No business logic in schemas, triggers, or stored procedures. |\n| **Utilities** | Cross-cutting | Infrastructure | Security, Logging, Diagnostics, Hosting, Configuration, Localization, Pub\u002FSub bus, Identity. Callable from any layer. No business logic. |\n\nNaming: `\u003CNounOfVolatility>Manager`, `\u003CGerund>Engine`, `\u003CNounOfResource>Access`. Atomic business\nverbs belong on **operations**, never on service names. `PricingEngine` beats `OrderService` when\npricing is the volatility boundary.\n\n**The four questions are also the validation pass.** After the design, re-ask them: is every Client\npure *who*, with no trace of *what*? Is every Manager free of *who* and *where*? Overlap is a red\nflag — unless you can still defend the encapsulation, in which case keep it.\n\n---\n\n## 4. Communication rules (closed architecture)\n\nClosed architecture trades flexibility for encapsulation. These are the sanctioned relaxations, not\na licence to improvise:\n\n1. Clients call **Managers only**. A Client must not call multiple Managers in one use case.\n2. Managers call **Engines and ResourceAccess**, and any Utility.\n3. Manager → Manager is **queued only** (pub\u002Fsub through the bus). Never synchronous.\n4. Engines never call Engines. Engines never call ResourceAccess. The Manager pulls, then passes in.\n5. Nothing calls upward. Engines and ResourceAccess never call Clients.\n6. ResourceAccess is the only path to a Resource. No ORM call in a Manager, no raw SQL in an Engine.\n7. Never queue calls to Engines or ResourceAccess. Engines and ResourceAccess do not publish or\n   subscribe to events.\n8. Between layers pass primitives, arrays of primitives, data contracts, arrays of data contracts.\n   Logic behind a data contract does not cross a layer. Passing \"entities\" breaks encapsulation.\n9. **Strive for symmetry.** Use cases that call in different shapes signal a design problem worth\n   investigating.\n10. When you feel you must \"open up\" the architecture, that is a signal you need pub\u002Fsub or\n    queuing — not a licence to break the rule. Name the underlying need; do not dismiss the\n    transgression.\n\nSubsystems: group Managers, Engines, and ResourceAccess into a cohesive slice. **Max 3 Managers per\nsubsystem.** A component inside a subsystem cannot be released alone — release one subsystem at a\ntime. Do not assume each slice is a microservice; a microservice may be a group of slices.\n\n**Golden ratio (Manager : Engine).** 1:(0 or 1), 2:1, 3:2, 5:3. As Managers grow, the need for\nEngines grows at a decelerating rate. Many Managers relative to Engines means you decomposed by\nfunction. Redesign. Order of magnitude for a whole system is ~10 components, not hundreds.\n\n---\n\n## 5. Workflow\n\n1. **Vision → objectives → mission.** Write the vision as a single sentence, legal-grade. Objectives\n   that do not serve the vision are cut. The mission states how the work is executed. This hierarchy\n   outranks architecture in argument; it is how you refuse irrelevant demands.\n2. **Use cases.** Separate **core use cases** (the essence of the business — the ones that do not\n   change unless the nature of the business changes) from the fluff (happy, sad, incomplete paths).\n   Use activity diagrams with swim lanes, not flowcharts.\n3. **Volatility list.** Work both axes. Mark each entry volatile or variable. Flag any entry that is\n   really a solution.\n4. **Map volatilities to components.** Rarely 1:1 — one component may absorb several volatilities,\n   some map to an operational concept or a third-party component. Classify each into the taxonomy.\n5. **Validate by call chains.** Take the top 4–6 distinct use cases and show them as interactions\n   between the minimal set of components. Iterate the factoring until every conceivable use case is\n   satisfiable by composition. **Any component that appears in no call chain is unnecessary.**\n6. **Check the shape.** Golden ratio, volatility decreasing top-down, reuse increasing top-down,\n   symmetry across call chains, ≤3 Managers per subsystem.\n7. **Allocation.** Assemblies, hosts\u002Fprocesses (layer boundary is usually process boundary; Engines\n   and ResourceAccess run in-proc to a Manager), identities (minimise; trusted subsystem pattern —\n   each layer authenticates its immediate caller), authentication\u002Fauthorization boundaries,\n   transactions (start as far upstream as possible, engulf as much as possible, keep under 1 second),\n   and logical threads of execution — any reentrant cyclic path means deadlock or a design error.\n8. **Project design** (§6) — only after the architecture exists.\n\n---\n\n## 6. Project design (the second half)\n\nProject design is the assembly instruction. It derives from the architecture, not from optimism.\n\n- **Core team** = project manager + product manager + architect, three roles, three people, present\n  for the whole project. The architect owns both the system design and the project design. One\n  architect for design integrity. **One developer per service, 1:1** — anything else cannot be\n  estimated reliably.\n- **Fuzzy front end** is 15–25% of project duration. Nothing is committed before cost, schedule, and\n  risk exist.\n- **Estimates are accurate, not precise.** Quantum of 5 days. Itemise the full lifecycle of every\n  service: learning curve, test client, installation, integration points, peer review, documentation.\n  PERT: `E = (T + 4M + P) \u002F 6`.\n- **Critical path** = longest path through the activity network = the duration of the project. No\n  project can be accelerated beyond it. Assign the best resources to the critical path first;\n  accelerating non-critical paths accelerates nothing.\n- **Floats are the project's safety margin and its risk meter.** Low float = high risk. Trade float\n  for resources deliberately.\n- **Risk index** (normalised 0–1): `Risk = (4C + 3R + 2Y + 1G) \u002F (4N)` over critical\u002Fred\u002Fyellow\u002Fgreen\n  activities. Acceptable band 0.3–0.75; decompress toward **0.5**. Crossover ≈ 0.75. Subcritical\n  staffing pushes risk to ~0.9 and costs at least 25% more for 35% longer — there is no saving.\n- **Present several options**, not one plan: cheapest, fastest, safest, best combination. Points above\n  the time-cost curve are feasible; points below it are impossible — a project committed below the\n  curve has already failed.\n- **God activities** (oversized, placeholder for uncertainty) must be broken up or factored out as\n  separate projects; they distort the whole risk calculation.\n\n---\n\n## 7. Output artifact\n\nWrite the design as a document with these sections, in order. Template:\n`assets\u002Fdesign_doc_template.md`.\n\n1. Vision, objectives, mission\n2. Core use cases (and the fluff, listed but not load-bearing)\n3. Volatility list — two axes, each entry marked volatile \u002F variable \u002F solution-in-disguise\n4. Component table — name, category, **the single axis of volatility it encapsulates**, what it calls\n5. Call chains for the top 4–6 use cases\n6. Allocation — assemblies, processes, identities, auth boundaries, transactions\n7. **Unassigned volatilities** and **components in no call chain** — see §8\n8. Project design options — duration, cost, risk index per option\n\n---\n\n## 8. The section that catches the gap\n\nTwo checks must be run against the actual document, not from memory, and reported plainly:\n\n- **Every volatility in §3 has an owner.** A volatility with no component is an assumption that the\n  change will never happen.\n- **Every component is in at least one call chain.** A component in no call chain is decoration.\n\nThen state whether the design is currently *validatable*: can the core use cases be walked as call\nchains with the components that exist in the document? If not, say so. A design document that lists\ncomponents it never uses reads as complete and is not.\n\n---\n\n## 9. Gotchas\n\n- **The allure is the problem.** Functional decomposition looks free. Design that costs no effort\n  adds no value — there is no free lunch. If a decomposition could be done by a tool, it is not\n  design.\n- **Volatility is not self-evident.** It takes longer than functional decomposition, and it fights\n  management. The Dunning–Kruger effect is the default state: people who cannot see the volatilities\n  are also the people most confident their decomposition is right.\n- **Do not design against the requirements** even when the deadline demands it. The deadline is paid\n  for in multiples later.\n- **Unit testing is the streetlight effect.** It is necessary and nearly useless on its own: defects\n  live in the interactions between units, and changing one unit invalidates the others. Regression\n  testing of interactions is the real check.\n- **The Method is not a silver bullet.** It does not remove creativity, responsibility for getting\n  the use cases right, or liability for getting it wrong. It mechanises the decisions so the crunch\n  is spent on judgment, not on enumeration.\n- **Time crunch is load-bearing.** 3–5 days, top 4–6 use cases, ~40–60 diagrams. Without the crunch\n  you get analysis-paralysis and gold-plating.\n- **Boxes and arrows communicate only so much.** Non-obvious decisions must be written down, with the\n  tradeoff that produced them.\n- **Do not mix architectures.** The taxonomy is the only one allowed in the system. Do not blend it\n  with DDD aggregates, Clean Architecture use-case layers, hexagonal ports, onion shells, or vertical\n  slices. If a hybrid is required, the volatility was mis-identified — fix that instead.\n\n---\n\n## 10. Routing\n\nRoutes here for: system design, architecture review, service decomposition, \"is this decomposition\nright?\", naming a component, validating a design against use cases, and the schedule\u002Fcost\u002Frisk\nquestion for a build.\n\nDoes **not** route here for: implementation (design authority is not build authority), detailed\ndesign — interfaces, class hierarchies, and idioms are below The Method and can change without\ntouching the decomposition — coding-style review, or technology selection.\n\nThe Method mechanises design decisions. It does not make the decisions. Every component in the output\nmust trace to a named volatility; a component with no volatility is reintroduced assumption.\n\n---\n\n## Changelog\n\n- v1.0.0 (2026-11-07) — Initial skill. Prime Directive, the two forbidden decompositions,\n  volatile-vs-variable, the two axes, the fixed taxonomy and the four questions, closed-architecture\n  communication rules, golden ratio and subsystem caps, call-chain validation, the mandatory\n  unassigned-volatility \u002F no-call-chain check, and the project-design half (core team, critical path,\n  floats, risk index, options). Distilled from the book's chapters 2–4 plus Löwy's SDD 2022 deck and\n  the InfoQ author interview.\n",{"name":5,"description":7},"main","454c51c0c7f4b36be2000915748cca72cf53ddd5",".agents\u002Fskills\u002Frighting-software","https:\u002F\u002Fgithub.com\u002Fzero8urn\u002Fagentic-goo","https:\u002F\u002Fgithub.com\u002Fzero8urn","zero8urn.github.io","2026-11-07 23:02:14",{"source":8,"skillName":5,"commands":62,"prompt":72,"zipAvailable":73},[63,66,69],{"tool":64,"command":65},"npx","npx skills add zero8urn\u002Fagentic-goo --skill righting-software",{"tool":67,"command":68},"bunx","bunx skills add zero8urn\u002Fagentic-goo --skill righting-software",{"tool":70,"command":71},"pnpm","pnpm dlx skills add zero8urn\u002Fagentic-goo --skill righting-software","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fzero8urn\u002Fagentic-goo\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Frighting-software\u002FSKILL.md",true,[75],{"path":76,"resourceType":77,"resourceTypeDesc":78,"sizeBytes":79,"sourceHtmlUrl":80},"assets\u002Fdesign_doc_template.md","ASSET","资产文件",1706,"https:\u002F\u002Fgithub.com\u002Fzero8urn\u002Fagentic-goo\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Frighting-software\u002Fassets\u002Fdesign_doc_template.md",[82,103,120,140],{"skillNo":83,"name":84,"nameZh":6,"description":85,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":86,"categories":87,"keywords":91,"publishedAt":49},"01M6WWANQTYQMAVKXJCC7G8CFH","to-syllabus","Turns a topic, a fixed experienced-developer audience, and a domain into a learning syllabus and a companion technical guide. Use when someone says \"syllabus this\" or asks to create a learning path framed inside a domain.","https:\u002F\u002Fgithub.com\u002Fzero8urn\u002Fagentic-goo\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fto-syllabus\u002FSKILL.md",[88],{"categoryNo":89,"categoryName":90,"taxonomyType":26,"taxonomyTypeDesc":27},"01JBSEEDCAT000000000000030","开发工程师",[92,93,94,95,96,97,98,42,99,100,101,102,32],"to syllabus","syllabus","create","developer","learning","technical","guide","domain","framed","companion","path",{"skillNo":104,"name":105,"nameZh":6,"description":106,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":107,"categories":108,"keywords":109,"publishedAt":49},"01M6WWAHG7HBE3KDQ4PREES7QX","to-icebox","Transforms a stream of thoughts, rough conversation, or scattered ideas into a structured feature request document. Use when someone says \"icebox this\".","https:\u002F\u002Fgithub.com\u002Fzero8urn\u002Fagentic-goo\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fto-icebox\u002FSKILL.md",[],[110,111,112,113,114,115,116,117,118,119,32,42],"to icebox","ideas","feature request","structured","conversation","feature","transforms","stream","request","document",{"skillNo":121,"name":122,"nameZh":6,"description":123,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":124,"categories":125,"keywords":126,"publishedAt":49},"01M6WWA5448YBVWMJJ1J2X2YZV","documentation-writer","Diátaxis Documentation Expert. An expert technical writer specializing in creating high-quality software documentation, guided by the principles and structure of the Diátaxis technical documentation authoring framework.","https:\u002F\u002Fgithub.com\u002Fzero8urn\u002Fagentic-goo\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fdocumentation-writer\u002FSKILL.md",[],[127,128,129,130,131,132,133,97,134,135,136,137,30,138,139],"documentation writer","documentation","writer","structure","technical documentation","framework","quality","technical writer","expert","documentation expert","authoring","principles","high",{"skillNo":141,"name":142,"nameZh":6,"description":143,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":144,"categories":145,"keywords":146,"publishedAt":49},"01M6WWA0S1MVFR8KXGBXHDBKPK","defensive-architecture-pr-review","Reviews pull request diffs against a legacy codebase using Juval Löwys Volatility-Based Decomposition (The Method). Detects architectural decay, leakage of business-rule volatility, and boundary infractions","https:\u002F\u002Fgithub.com\u002Fzero8urn\u002Fagentic-goo\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fdefensive-architecture-pr-review\u002FSKILL.md",[],[147,148,149,150,151,47,152,153,154,155,45,156,157,158,159,160,161,162,118],"defensive architecture pr review","defensive","review","pr","pr review","decay","diffs","pull request","pull","boundary","business","Legacy","decomposition","rule","reviews","codebase"]