# a-philosophy-of-software-design

Adopt this skill: https://proskills.md/skills/other/ciembor-agent-rules-books-a-philosophy-of-software-design

Page: https://proskills.md/skills/other/ciembor-agent-rules-books-a-philosophy-of-software-design
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: a-philosophy-of-software-design/SKILL.md
size: 723
sha: 29632dc2fe09a7b1a14b489cf7cac6b6b4453466
upstream: https://github.com/ciembor/agent-rules-books/blob/main/a-philosophy-of-software-design/SKILL.md

```text
---
name: a-philosophy-of-software-design
description: Apply John Ousterhout-inspired software design rules when reducing complexity, designing module boundaries, or reviewing APIs and abstractions.
license: MIT
---

# A Philosophy of Software Design Skill

Use this skill when a task involves module design, API design, information hiding, abstraction depth, cognitive load, or refactoring shallow interfaces.

Before making design or code decisions, read and apply [a-philosophy-of-software-design.mini.md](a-philosophy-of-software-design.mini.md). Use [a-philosophy-of-software-design.md](a-philosophy-of-software-design.md) only as a deeper reference when the mini rules are not enough for the current design tradeoff.
```

## File: a-philosophy-of-software-design/a-philosophy-of-software-design.md
size: 13561
sha: 02d9d5410165937d74c55cd17d9427175180343f
upstream: https://github.com/ciembor/agent-rules-books/blob/main/a-philosophy-of-software-design/a-philosophy-of-software-design.md

```text
# OBEY A Philosophy of Software Design by John Ousterhout

## Purpose

This repository follows **A Philosophy of Software Design** in the sense of John Ousterhout:
fight complexity directly by designing modules with deep value, clean interfaces, strong information hiding, and low cognitive load.

All code generation, edits, and reviews must optimize for:
- lower complexity
- deeper modules
- simpler interfaces
- stronger information hiding
- fewer special cases
- clear separation between interface and implementation
- strategic design over tactical patching

This file is a binding engineering policy: `MUST` is binding, `SHOULD` is a strong default, and `MUST NOT` is forbidden.

---

## Primary Directive

Complexity is anything that makes software hard to understand or hard to change.

When uncertain, prefer the design that:
1. reduces the number of things a reader must know at once
2. hides more details behind a stable interface
3. eliminates exceptions and awkward cases
4. creates a deeper module instead of a shallower one
5. lowers future cognitive load, not just present typing effort

Do not optimize for shorter files, fewer lines, or clever compactness if complexity rises.

---

## Core Complexity Rules

### Symptoms of Complexity
Treat these as architectural warnings:
- change amplification
- cognitive load
- unknown unknowns
- hidden dependencies
- information spread across many places
- temporal coupling that readers must reconstruct mentally

### Default Response
When a feature feels awkward, first ask:
- is the interface too wide?
- is the behavior scattered?
- are details leaking that should be hidden?
- are there too many special cases?
- are we solving a tactical local problem while increasing global complexity?

---

## Module Depth Rules

### Prefer Deep Modules
A deep module offers a simple interface but hides substantial complexity behind it.

Rules (MUST unless marked SHOULD or MUST NOT):
1. Design modules to hide meaningful internal complexity.
2. Prefer a small interface with strong semantics over a large surface with minor helpers.
3. Make each module carry its own weight.
4. A module that only forwards work is usually too shallow.

### Avoid Shallow Modules
Shallow modules are bad when:
- the interface exposes almost as much complexity as the implementation
- layers exist mostly to redirect calls
- small wrappers multiply concepts without reducing reader burden

Anti-patterns (MUST NOT):
- pass-through service classes
- thin wrappers around libraries with no simplification
- helper modules that only rename obvious operations

---

## Information Hiding Rules

1. Hide design decisions that are likely to change.
2. Hide internal data representations.
3. Hide incidental workflow steps and bookkeeping.
4. Keep callers from depending on implementation detail, performance hacks, or storage shape.
5. Encapsulate messy edge conditions and normalization logic.

Anti-patterns (MUST NOT):
- exposing internal representation or state through module interfaces
- leaking storage, protocol, framework, or file-format details through module interfaces
- callers coordinating object internals across multiple modules

---

## Interface Design Rules

1. Design interfaces around what clients need to know, not how the implementation works.
2. Keep interfaces narrow but meaningful.
3. Avoid APIs that require callers to stage operations in fragile sequences.
4. Eliminate arguments that only exist to expose internal implementation choices.
5. Use names and method shapes that reveal the abstraction, not the mechanism.

Good interface signs (SHOULD):
- few methods
- strong semantic guarantees
- limited required context
- callers do not need to understand internals

Bad interface signs (warning; usually MUST NOT):
- many configuration flags
- call-order traps
- multiple setup methods required before use
- booleans and mode parameters switching internal behavior

---

## Strategic Programming over Tactical Programming

### Strategic Programming
1. Spend time reducing future complexity, not only making the current change pass.
2. Reshape abstractions when recurring friction appears.
3. Invest in interfaces and decomposition that make future changes local.
4. Leave behind clearer structure after every substantial edit.

### Tactical Programming
Avoid:
- patching local symptoms while increasing global complexity
- copy/paste to meet a deadline
- exposing one more internal detail instead of designing a better boundary
- adding flags and exceptions to avoid a better abstraction

---

## General-Purpose vs Special-Purpose Modules

1. Prefer modules that capture a reusable concept at the right abstraction level.
2. Do not overfit interfaces to one narrow caller if a slightly more general concept is obvious.
3. Do not generalize so far that the abstraction becomes vague.
4. The best module is specific enough to be strong and general enough to be reusable within its domain.

---

## Error Handling and Exception Elimination

1. Define APIs that make misuse hard.
2. Define away invalid states and awkward cases where possible.
3. Eliminate exception cases by changing the interface or invariant, not only by adding more checks.
4. Use special/general decomposition when unusual cases clutter the main abstraction.
5. Keep the normal path obvious and the exceptional path isolated.

Anti-patterns (MUST NOT):
- APIs that require every caller to repeat defensive ceremony
- “special case” branches scattered across many call sites
- exposing half-valid objects and asking callers to tiptoe around them

---

## Pull Complexity Downward

1. Put complexity in one place rather than many.
2. Hide intricate logic behind a simpler public contract.
3. Prefer a slightly more complex implementation if it makes all callers simpler.
4. Remove repeated reasoning burdens from call sites.

This is the opposite of pushing complexity outward through flags, setup steps, and coupled operations.

---

## Comment Rules

Comments must reduce complexity, not narrate obvious code.

Use comments for:
- interface contracts
- non-obvious invariants
- hidden design decisions
- the reason an abstraction exists
- tricky implementation facts callers do not need to know

Do not use comments to compensate for:
- bad naming
- poor decomposition
- confusing control flow
- missing abstraction

---

## Function and Variable Rules

1. Keep functions deep enough to hide a meaningful amount of work.
2. Avoid long functions only when they create cognitive load, not as a numeric ritual.
3. Avoid pass-through variables that do not add meaning.
4. Use variables to capture meaning, not to mirror syntax.
5. Keep local details local.

Anti-patterns (MUST NOT):
- chains of tiny functions where readers must jump constantly to understand one idea
- variables introduced only to satisfy style rather than clarity
- exposing intermediate states that should stay internal

---

## Temporal Decomposition Rules

1. Do not structure modules primarily around execution order if the real structure is conceptual.
2. Prefer decomposition around stable concepts and responsibilities.
3. Initialization steps, processing phases, and cleanup stages should not force readers to reconstruct the design from time-order alone.
4. Keep call ordering simple and explicit where it matters.

Anti-patterns (MUST NOT):
- `prepare/process/finalize` everywhere without domain concepts
- APIs that require secret temporal knowledge
- partial objects whose meaning depends on which phase has already run

---

## Special-General Decomposition

Use special-general decomposition when a small number of exceptions are cluttering the main logic.

Rules (MUST unless marked SHOULD or MUST NOT):
1. Keep the general case simple.
2. Isolate the unusual or rare behavior.
3. Do not pollute the main abstraction with every edge case.

This is preferable to accreting conditionals into the core path forever.

---

## Combine or Separate Code

1. Separate code only when the separation reduces complexity, hides a real design decision, or creates a stronger abstraction.
2. Combine code when split pieces force readers to jump between shallow fragments to understand one idea.
3. Keep related state, behavior, and invariants together when separating them would create change amplification.
4. Do not preserve a boundary merely because it already exists if it exposes almost as much complexity as it hides.
5. Prefer one coherent deeper module over several tiny modules that require callers to coordinate details.

Anti-patterns (MUST NOT):
- splitting code by execution phase when the stable concept is not temporal
- separating normal and special cases so far apart that their shared invariant is hidden
- adding helper layers that distribute one design decision across many files

---

## Design Alternatives and Comments-First Design

1. For non-trivial design choices, compare at least two plausible designs before implementing the first one that works.
2. Evaluate alternatives by interface simplicity, information hiding, special-case reduction, and future cognitive load.
3. When an interface or abstraction is unclear, sketch the public contract and explanatory comments before committing to implementation.
4. Use comments-first design to clarify abstraction boundaries, not to preserve vague or misleading code.
5. Revise the abstraction when the comment needed to explain it becomes complicated.

Anti-patterns (MUST NOT):
- accepting the first design because it is locally convenient
- using comments to justify a confusing interface instead of changing the interface
- documenting implementation mechanics that callers should not need to know

---

## Naming, Consistency, and Obviousness

1. Names must reveal the abstraction, not the internal mechanism.
2. Use consistent names, argument order, error behavior, and interface conventions for related operations.
3. Prefer obvious code where a reader can infer behavior from local structure and names.
4. Remove non-obvious behavior unless it is hidden behind a clear contract.
5. When code surprises a reader, treat that as complexity even if the code is short.

---

## Performance, Trends, and Tests

1. Do not sacrifice module depth or information hiding for performance without evidence that the tradeoff matters.
2. When performance matters, hide optimization details behind stable interfaces so callers do not inherit the complexity.
3. Prefer measurements and targeted changes over broad speculative tuning.
4. Do not adopt a trend, paradigm, pattern, or framework unless it reduces complexity in this codebase.
5. Use tests to preserve behavior while changing structure, but do not let test convenience force shallow or leaky interfaces.

---

## Review Rules

When reviewing code, actively look for:
- shallow modules
- pass-through layers
- interfaces that expose implementation detail
- excessive flags or mode parameters
- scattered special cases
- cognitive load caused by too many interacting modules
- hidden temporal constraints
- complexity pushed to callers
- comments that explain what should be encoded in structure
- tactical patches that increase future difficulty

---

## Forbidden Patterns

### Shallow Decomposition
- splitting code into many tiny units that do not reduce understanding cost
- wrappers and facades that add names but not simplification

### Interface Leakage
- APIs that expose storage, transport, or caching mechanics to ordinary callers
- method sequences that require callers to know internal workflow

### Tactical Complexity Debt
- adding one more flag, callback, or conditional instead of improving the abstraction
- fixing the local symptom while making the design harder overall

### Complexity Spread
- repeating the same special handling in many places
- making all callers responsible for one module's awkwardness

---

## Code Generation Rules

When generating code, default to:
1. identify the concept that deserves a module boundary
2. design the narrowest strong interface around that concept
3. hide volatile or complicated details inside
4. simplify all callers, even if implementation grows slightly
5. isolate special cases
6. reduce the number of facts a reader must juggle at once

Avoid by default:
- pass-through layers
- needless tiny abstractions
- exposing internal data formats
- temporal APIs with fragile call sequences
- multiplying concepts without reducing complexity

---

## Testing Rules

1. Test public behavior and interface contracts.
2. Test hidden complexity through stable public APIs where possible.
3. Add focused tests around isolated special cases.
4. Avoid tests that force callers to know implementation detail if the abstraction promises otherwise.

---

## Review Checklist

Before finalizing any change, verify:
- Did this change reduce or increase cognitive load?
- Is the module deeper or shallower after the edit?
- Did we hide more complexity behind a stable interface?
- Did we reduce special-case handling at call sites?
- Did we remove an implementation detail from the public surface?
- Did we avoid a pass-through layer?
- Does the interface describe the abstraction rather than the mechanism?
- Did we improve future changeability, not just present convenience?

If any answer is no, revise before shipping.

---

## Final Instruction

When uncertain, prefer the design that:
1. creates a deeper module
2. hides more complexity
3. reduces special cases
4. lowers cognitive load for callers
5. improves the abstraction instead of patching around it

Fight complexity directly.
```

## File: a-philosophy-of-software-design/a-philosophy-of-software-design.mini.md
size: 5774
sha: a7d88383dd909a97b423d5f54d308cb2049e9a5a
upstream: https://github.com/ciembor/agent-rules-books/blob/main/a-philosophy-of-software-design/a-philosophy-of-software-design.mini.md

```text
# OBEY A Philosophy of Software Design by John Ousterhout

## When to use

Use for module design, API changes, decomposition, refactoring, naming, comments, tests, performance work, and changes that feel awkward or spread complexity across files.

## Primary bias to correct

Working code, small pieces, familiar patterns, flags, wrappers, and extra documentation do not make a design simple when they increase cognitive load or leak knowledge.

## Decision rules

- Use reduced complexity as the primary success metric. Prefer the design that lowers cognitive load, change amplification, hidden dependencies, temporal coupling, and the number of facts a reader must hold at once.
- Treat design as continuous work. A first working patch is not done if it worsens future changeability; compare plausible alternatives for non-trivial interface, decomposition, or abstraction choices.
- Prefer deep modules: small, semantic interfaces that hide meaningful internal complexity. Reject pass-through services, thin library wrappers, helper modules, and tiny split-outs that add names without reducing reader burden.
- Design interfaces around what callers need to know, not how the implementation works. Avoid fragile staging, setup sequences, mode flags, configuration knobs, and arguments that expose internal choices.
- Hide volatile decisions, internal representations, storage shape, protocols, file formats, performance hacks, bookkeeping, normalization, and messy edge handling inside the module that owns the knowledge.
- Pull complexity downward when the lower module owns the detail. Prefer a slightly more complex implementation if it gives callers a simpler public contract and removes repeated reasoning from call sites.
- Choose generality at the right level. Avoid one-caller overfitting, vague speculative abstractions, and core paths polluted by rare edge cases; isolate special behavior with special-general decomposition.
- Combine or split by total complexity, not by size, runtime order, habit, or aesthetics. Keep related state, behavior, invariants, and design decisions together unless the new boundary is deeper and independently understandable.
- Reduce exception surface by changing interfaces or invariants where possible. Define away invalid states and awkward cases instead of making every caller repeat defensive ceremony.
- Use comments to reduce complexity: document interface contracts, invariants, hidden design decisions, rationale, and tricky implementation facts callers should not need to know. Do not narrate code or compensate for bad names, poor decomposition, or confusing flow.
- Treat names, consistency, and obviousness as design information. Names should reveal abstractions rather than mechanisms; related operations should share conventions; surprising code is complexity even when short.
- Use tests to protect behavior through public contracts and stable APIs, especially around hidden complexity and isolated special cases. Do not let test convenience force shallow or leaky interfaces.
- Add performance optimizations, trends, paradigms, patterns, or frameworks only when they reduce complexity in this codebase or evidence shows the tradeoff matters; hide optimization details behind stable interfaces.

## Trigger rules

- When a feature feels awkward, one change spreads across files, or reviewers must reconstruct hidden dependencies, look for missing information hiding, shallow modules, temporal coupling, or complexity pushed to callers.
- When adding a module, layer, service, helper, wrapper, facade, pattern, option, callback, or argument, prove that it hides more complexity than it adds.
- When touching an API, check whether ordinary callers must know sequencing, representation, storage, transport, caching, protocol, file format, internal workflow, or too many setup steps.
- When adding a special case, flag, exception path, conditional, or exposed container, first ask whether the owning module can eliminate the invalid state, isolate the unusual behavior, or provide a stronger operation.
- When splitting, extracting, or introducing variables, check whether the new boundary or name captures meaning or only adds jumps, pass-through state, and visible intermediate steps.
- When code is organized as `prepare/process/finalize`, staged objects, or other execution-order phases, verify that temporal structure is the real concept; otherwise reorganize around stable responsibilities.
- When naming is vague, mechanism-focused, inconsistent, or surprising, reconsider the abstraction boundary instead of accepting a near miss.
- When comments get long, duplicate code, justify a confusing interface, or explain usage by exposing internals, redesign the abstraction or move the missing contract to the interface.
- When optimizing performance, measure first and hide the optimization; do not sacrifice module depth or information hiding without evidence that the tradeoff matters.
- When testing or reviewing, focus on public behavior, interface contracts, hidden complexity through stable APIs, and special cases isolated behind the abstraction.

## Final checklist

- Did the change reduce the effort required to understand, modify, verify, and extend the system?
- Does every interface element, wrapper, layer, helper, option, and name hide enough complexity to justify its existence?
- Are important decisions localized, dependencies visible, caller-needed constraints documented, and mutable internals protected?
- Did common cases become automatic while rare controls, special cases, performance tricks, and exception details stayed out of the common path?
- Are names precise and consistent, comments current and non-duplicative, and conventions followed unless new information justified changing them?
```

## File: a-philosophy-of-software-design/a-philosophy-of-software-design.nano.md
size: 2258
sha: 866c3e0c2f49416e461aca74c013afd1e8123098
upstream: https://github.com/ciembor/agent-rules-books/blob/main/a-philosophy-of-software-design/a-philosophy-of-software-design.nano.md

```text
# OBEY A Philosophy of Software Design by John Ousterhout

## When to use

Use when the main risk is accidental complexity, shallow abstractions, leaky interfaces, or tactical patches.

## Primary bias to correct

Working code, small pieces, and familiar wrappers are not automatically simple.

## Decision rules

- Optimize for lower cognitive load and local understandability, not shorter files, familiar patterns, fewer lines, or clever compactness.
- Prefer deep modules; reject wrappers, layers, helpers, facades, and split-outs that do not hide real complexity.
- Hide volatile decisions, representations, storage, protocol facts, workflow bookkeeping, and messy edge handling in one owning module.
- Make interfaces caller-centered and semantic; avoid staged APIs, flags, setup sequences, and mechanism leakage when the module can provide the right operation.
- If a change feels awkward or spreads widely, improve ownership and abstraction instead of adding tactical special cases.
- Combine or split by total complexity: keep shared knowledge together and split only at independently understandable boundaries.
- Treat names and comments as design signals: precise abstraction names, explicit contracts, and no comments that compensate for bad decomposition.
- Add complexity for performance, trends, patterns, frameworks, tests, or exception handling only when evidence or caller needs justify it.

## Trigger rules

- When adding a helper, layer, option, callback, pattern, or abstraction, prove it removes complexity for callers.
- When an API requires sequencing, representation, storage, transport, caching, protocol, or file-format knowledge, redesign the boundary.
- When naming is hard, comments get long, or reviewers are surprised, treat it as design evidence.
- When one change spreads widely, look for duplicated knowledge, hidden dependencies, temporal coupling, or the wrong owner.
- When optimizing or adding exception paths, keep the common path simple and require evidence or a stronger invariant.

## Final checklist

- Fewer concepts to hold?
- More complexity hidden below the right boundary?
- Fewer special cases, knobs, leaks, and call-order traps?
- Better names, contracts, ownership, and evidence for any added complexity?
```

## File: README.md
upstream: https://github.com/ciembor/agent-rules-books/blob/main/README.md

````text
[![Polish Repo badge](https://polish-open-source.pl/en/badges/repositories/github/ciembor/agent-rules-books.svg)](https://polish-open-source.pl/en/latest)
[![skills.sh](https://skills.sh/b/ciembor/agent-rules-books)](https://skills.sh/ciembor/agent-rules-books)

<div align="center">
  <img src="books-ai-rules.png" alt="AI agent rules from programming books" />
  <h1 align="center">AI agents Rules / Skills from<br />Programming Books v0.6</h1>

  <p align="center">
    <strong>AGENTS.md rules</strong> / <strong>skills</strong> for <strong>Codex</strong>, <strong>Cursor</strong>, <strong>Claude Code</strong>, distilled from classic <strong>software engineering books</strong> about refactoring, architecture, DDD and code quality.
  </p>

  <p align="center">
    <a href="#about">About</a>
    ·
    <a href="#installation-as-skills">Installation</a>
    ·
    <a href="#release-matrix">Rules / Skills</a>
    ·
    <a href="#books-list">Books List</a>
    ·
    <a href="docs/USAGE.md">Usage</a>
    ·
    <a href="docs/COMPATIBILITY.md">Books Compatibility</a>
  </p>
</div>

## About
MIT licensed universal project rules for coding agents.

This repository contains ready-to-use rule sets inspired by well-known books on software design, architecture, refactoring, legacy code, reliability, and data-intensive systems.

For editor-specific setup in Codex, Claude Code, and Cursor, see [USAGE.md](docs/USAGE.md). It covers always-on vs on-demand usage, skills, scoped rules, and the preferred setup for each editor.

Each rule set is released in three tool-agnostic Markdown versions:

- `mini`: the recommended version for most real task use
- `nano`: the compact fallback for very tight context budgets
- `full`: the canonical complete source and reference version

For constructive criticism from Reddit, see [CRITICISM.md](docs/CRITICISM.md).

For release history, see [CHANGELOG.md](CHANGELOG.md).

## Installation as Skills

Prerequisite: install Node.js with npm. You can run the Skills CLI through `npx` without installing `skills` separately.

Install all book skills with the open Agent Skills CLI:

```sh
npx skills add ciembor/agent-rules-books --all
```

List available skills without installing:

```sh
npx skills add ciembor/agent-rules-books --list
```

Install one selected skill:

```sh
npx skills add ciembor/agent-rules-books --skill refactoring
```

Every book directory contains a standard `SKILL.md` entrypoint. The skill loads the corresponding `mini` rule set by default and keeps the `full` file available as deeper reference material.

If you prefer another setup, see [USAGE.md](docs/USAGE.md) for manual, scoped, always-on, and editor-specific installation patterns.

## Release Matrix

Metrics:

- `lines`: physical line count from `wc -l`
- `rules`: Markdown list items counted with the deterministic release convention
- `size`: raw bytes from `wc -c`

| Rule Set | Full file | Full lines | Full rules | Full size | Mini file | Mini lines | Mini rules | Mini size | Nano file | Nano lines | Nano rules | Nano size |
| --- | --- | ---: | ---: | ---: | --- | ---: | ---: | ---: | --- | ---: | ---: | ---: |
| [A Philosophy of Software Design](a-philosophy-of-software-design/) | [full](a-philosophy-of-software-design/a-philosophy-of-software-design.md) | 370 | 177 | 13561 B | [mini](a-philosophy-of-software-design/a-philosophy-of-software-design.mini.md) | 46 | 28 | 5774 B | [nano](a-philosophy-of-software-design/a-philosophy-of-software-design.nano.md) | 35 | 17 | 2258 B |
| [Clean Architecture](clean-architecture/) | [full](clean-architecture/clean-architecture.md) | 515 | 289 | 17782 B | [mini](clean-architecture/clean-architecture.mini.md) | 49 | 31 | 5486 B | [nano](clean-architecture/clean-architecture.nano.md) | 36 | 18 | 2254 B |
| [Clean Code](clean-code/) | [full](clean-code/clean-code.md) | 297 | 220 | 13851 B | [mini](clean-code/clean-code.mini.md) | 47 | 29 | 3804 B | [nano](clean-code/clean-code.nano.md) | 32 | 14 | 1235 B |
| [Code Complete](code-complete/) | [full](code-complete/code-complete.md) | 354 | 180 | 12407 B | [mini](code-complete/code-complete.mini.md) | 56 | 38 | 6717 B | [nano](code-complete/code-complete.nano.md) | 41 | 23 | 2544 B |
| [Designing Data-Intensive Applications](designing-data-intensive-applications/) | [full](designing-data-intensive-applications/designing-data-intensive-applications.md) | 393 | 205 | 16084 B | [mini](designing-data-intensive-applications/designing-data-intensive-applications.mini.md) | 55 | 37 | 6949 B | [nano](designing-data-intensive-applications/designing-data-intensive-applications.nano.md) | 34 | 16 | 2575 B |
| [Domain-Driven Design](domain-driven-design/) | [full](domain-driven-design/domain-driven-design.md) | 979 | 523 | 42424 B | [mini](domain-driven-design/domain-driven-design.mini.md) | 48 | 30 | 5683 B | [nano](domain-driven-design/domain-driven-design.nano.md) | 39 | 21 | 2266 B |
| [Domain-Driven Design Distilled](domain-driven-design-distilled/) | [full](domain-driven-design-distilled/domain-driven-design-distilled.md) | 317 | 158 | 11351 B | [mini](domain-driven-design-distilled/domain-driven-design-distilled.mini.md) | 56 | 38 | 6438 B | [nano](domain-driven-design-distilled/domain-driven-design-distilled.nano.md) | 41 | 23 | 2535 B |
| [Implementing Domain-Driven Design](implementing-domain-driven-design/) | [full](implementing-domain-driven-design/implementing-domain-driven-design.md) | 337 | 177 | 12848 B | [mini](implementing-domain-driven-design/implementing-domain-driven-design.mini.md) | 57 | 39 | 7333 B | [nano](implementing-domain-driven-design/implementing-domain-driven-design.nano.md) | 37 | 19 | 2723 B |
| [Patterns of Enterprise Application Architecture](patterns-of-enterprise-application-architecture/) | [full](patterns-of-enterprise-application-architecture/patterns-of-enterprise-application-architecture.md) | 404 | 196 | 15501 B | [mini](patterns-of-enterprise-application-architecture/patterns-of-enterprise-application-architecture.mini.md) | 54 | 36 | 8099 B | [nano](patterns-of-enterprise-application-architecture/patterns-of-enterprise-application-architecture.nano.md) | 35 | 17 | 2823 B |
| [Refactoring](refactoring/) | [full](refactoring/refactoring.md) | 433 | 242 | 17866 B | [mini](refactoring/refactoring.mini.md) | 49 | 31 | 5167 B | [nano](refactoring/refactoring.nano.md) | 37 | 19 | 1986 B |
| [Release It!](release-it/) | [full](release-it/release-it.md) | 382 | 204 | 13542 B | [mini](release-it/release-it.mini.md) | 48 | 30 | 6372 B | [nano](release-it/release-it.nano.md) | 38 | 20 | 2205 B |
| [The Pragmatic Programmer](the-pragmatic-programmer/) | [full](the-pragmatic-programmer/the-pragmatic-programmer.md) | 359 | 179 | 13398 B | [mini](the-pragmatic-programmer/the-pragmatic-programmer.mini.md) | 65 | 47 | 7165 B | [nano](the-pragmatic-programmer/the-pragmatic-programmer.nano.md) | 44 | 26 | 2263 B |
| [Working Effectively with Legacy Code](working-effectively-with-legacy-code/) | [full](working-effectively-with-legacy-code/working-effectively-with-legacy-code.md) | 371 | 193 | 13817 B | [mini](working-effectively-with-legacy-code/working-effectively-with-legacy-code.mini.md) | 50 | 32 | 5707 B | [nano](working-effectively-with-legacy-code/working-effectively-with-legacy-code.nano.md) | 35 | 17 | 1792 B |
| [Refactoring.Guru](refactoring-guru/) | [full](refactoring-guru/refactoring-guru.md) | 765 | 478 | 62561 B | [mini](refactoring-guru/refactoring-guru.mini.md) | 64 | 46 | 6287 B | [nano](refactoring-guru/refactoring-guru.nano.md) | 41 | 23 | 2593 B |

## Books List

### [A Philosophy of Software Design](https://www.goodreads.com/book/show/39996759-a-philosophy-of-software-design)

Author: [John Ousterhout](https://web.stanford.edu/~ouster/cgi-bin/home.php)

The book focuses on fighting complexity through deep modules, simple interfaces, information hiding, and design choices that reduce cognitive load. This rule set is especially useful for API design, modul
````
