[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7AMR9RQWRZBEE60T2ETP6CV":3,"skill-same:01M7AMR9RQWRZBEE60T2ETP6CV":48},{"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":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":24,"commitSha":25,"skillDirectory":26,"forksCount":27,"repositoryHtmlUrl":28,"repositoryHomepageUrl":29,"ownerHtmlUrl":30,"ownerBlogUrl":31,"ownerDescription":32,"updatedAt":33,"install":34,"resources":47},"01M7AMR9RQWRZBEE60T2ETP6CV","patterns-reference",null,"Use when checking a pattern anti-pattern — over-application is the dominant failure mode in this domain — weighing a contested question, confirming whether a claim is still current (snapshot verified August 2026), finding the books and sources, or needing the problem-to-pattern table and the checklist to run before adding a pattern. Companion to the other design-patterns skills.","the-vibey-project\u002Fvibey","the-vibey-project","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F329298758?v=4","01M7AJHGZ9722CTJ4JNQZVRH0Q","the vibey project","01M7AJHGZVMG2K7TGXQ6XFHVG3",5,"MIT","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fdesign-patterns\u002Fskills\u002Fpatterns-reference\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: patterns-reference\ndescription: \"Use when checking a pattern anti-pattern — over-application is the dominant failure mode in this domain — weighing a contested question, confirming whether a claim is still current (snapshot verified August 2026), finding the books and sources, or needing the problem-to-pattern table and the checklist to run before adding a pattern. Companion to the other design-patterns skills.\"\n---\n\n# Design Patterns: Anti-Patterns, Contested Questions, Currency, and Canon\n\n> **Part 5 of 5** of the *Design Patterns* reference (plugin `design-patterns`), covering §14–§20. Sibling skills: `patterns-foundations-gof-and-alternatives` (§0–§5), `patterns-architectural` (§6–§7), `patterns-distributed-concurrency-and-messaging` (§8–§11), `patterns-llm-agentic-and-legacy-migration` (§12–§13). Section numbers are shared across the set; a reference written as §N → `skill` points into that sibling skill.\n>\n> **Currency:** Verified August 2026. See §17 below for the currency snapshot and what goes stale first.\n\n> **How to read this.** Reference, not a catalogue. **The 23 GoF patterns are freely\n> available with diagrams and code samples everywhere** — this document does not reproduce\n> them. It addresses the harder questions: which ones still earn their keep, which ones\n> are artifacts of 1994's languages, what replaced them, where the genuinely useful\n> modern patterns live, and **when not to use any of them.**\n>\n> Three markers:\n> - **[DURABLE]** — design forces that recur regardless of language or era.\n> - **[VERSIONED]** — language features, framework practice, emerging pattern languages.\n> - **[CONTESTED]** — genuine disagreement, and **this domain has more of it than most.**\n>\n> **⚠️ GOTCHA** boxes mark where applying a pattern makes things worse.\n>\n> **The three framings that organize everything below:**\n> 1. **Patterns are a vocabulary, not a construction kit.** Their durable value is that\n>    \"this is a circuit breaker\" communicates a design in four words. **Their value was\n>    never that you should go looking for places to install them** — and treating the\n>    catalogue as a checklist is the single most damaging misreading of the entire\n>    literature (§14).\n> 2. **A pattern is a solution to a *force*, and the force is what's durable — not the\n>    implementation.** Many GoF implementations were workarounds for what C++ and Java\n>    couldn't express in 1994. **The forces persisted; the workarounds became language\n>    features** (§3 → `patterns-foundations-gof-and-alternatives`). Learn to see the force.\n> 3. **Over-application is the dominant failure mode, by a wide margin.** The cost of a\n>    missing pattern is some duplication you can refactor later. **The cost of an unneeded\n>    pattern is permanent indirection that every future reader must decode.** As one\n>    2026 practitioner framing puts it: add a pattern only when it removes duplication,\n>    isolates change, or clarifies intent — **and if introducing it makes the code harder\n>    to explain, it's the wrong moment for it.**\n\n---\n\n## §14. Anti-Patterns\n\n**[DURABLE] Naming these is at least as valuable as naming the patterns.**\n\n**Structural**: **God object \u002F god class**, **anemic domain model** (⚠️ **data-bags plus a\nservice layer — arguably the default outcome of layered architecture done carelessly**),\n**spaghetti**, **lasagna** (so many layers each adds nothing), **big ball of mud**,\n**circular dependencies**, **feature envy**, **shotgun surgery** (one change touches\nfifteen files).\n\n**Pattern-specific**: **Singleton abuse** (⚠️ **global mutable state with a design-pattern\nname on it** — hostile to testing, hides dependencies, causes ordering bugs), **Service\nLocator** (§5 → `patterns-foundations-gof-and-alternatives`), **the Poltergeist** (a class that exists only to call another),\n**BaseBean** (inheriting for convenience rather than for an is-a relationship),\n**over-abstracted factories**.\n\n**Process**: **premature optimization**, **premature generalization** (⚠️ **\"we might need\nthis later\" is the most expensive sentence in software**), **cargo cult architecture**\n(⚠️ **adopting Netflix's architecture at 1\u002F10000th of Netflix's scale**), **resume-driven\ndevelopment**, **the distributed monolith** (⚠️ **microservices that must deploy together —\nall the cost, none of the benefit, and the most common microservice failure mode**),\n**golden hammer**, **not-invented-here**, **stringly-typed** code, **magic numbers**,\n**boat anchor** (dead code kept \"just in case\"), **feature toggle debt**.\n\n> **⚠️ GOTCHA — pattern over-application, stated plainly, because it is the failure mode\n> this whole document exists to prevent.** Symptoms: interfaces with exactly one\n> implementation; factories that construct one type; three layers of indirection between\n> the caller and the work; class names ending in `Manager`, `Helper`, `Processor`, or\n> `AbstractProxyFactoryBean`; **you cannot find where anything actually happens.**\n>\n> **The asymmetry that should govern your default**: a missing pattern costs you some\n> duplication, which you can refactor when the third case appears and you can see the real\n> shape. **An unnecessary pattern costs every future reader permanently, and is far harder\n> to remove than to add.** When in doubt, don't.\n\n---\n\n## §15. Anti-Patterns Table\n\n| Anti-pattern | Why |\n|---|---|\n| Learning patterns as a catalogue to install | **\"Conformity to patterns is not a measure of goodness\"** — Ralph Johnson, GoF co-author (§1 → `patterns-foundations-gof-and-alternatives`) |\n| Adding a pattern that makes the code harder to explain | That's the signal it's premature (§2.3 → `patterns-foundations-gof-and-alternatives`) |\n| Hand-rolling Iterator in a language with iteration | ⚠️ The language is the pattern (§3.1 → `patterns-foundations-gof-and-alternatives`) |\n| Singleton for shared state | **Global mutable state with a nice name** (§14) |\n| Interface with exactly one implementation \"for testing\" | Modern test tooling fakes concrete types (§5 → `patterns-foundations-gof-and-alternatives`) |\n| Service Locator instead of DI | Hides dependencies rather than declaring them (§5 → `patterns-foundations-gof-and-alternatives`) |\n| Container magic you can't trace by reading | Runtime failures where compile-time ones belonged (§5 → `patterns-foundations-gof-and-alternatives`) |\n| Hexagonal architecture over a CRUD app | ⚠️ **If domain logic is thin, you don't need it** (§6.2 → `patterns-architectural`) |\n| Tactical DDD without the strategic work | Ceremony without the benefit (§6.3 → `patterns-architectural`) |\n| Microservices when teams aren't blocked on deploys | Paying the cost, not collecting the benefit (§7 → `patterns-architectural`) |\n| Microservices that must deploy together | ⚠️ **Distributed monolith** (§14) |\n| Adopting a hyperscaler's architecture at 1\u002F10000th the scale | Cargo cult (§14) |\n| Writing to your DB then publishing an event | ⚠️ **The dual-write problem. Real systems lose orders this way** (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Event Sourcing for CRUD | ⚠️ **Four months for a two-week feature, then rewritten** (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Choreographed saga past ~3 steps | Becomes impossible to reason about (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Treating compensation as rollback | The intermediate state was visible (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Synchronous external call with no circuit breaker | Cascading failure (§9 → `patterns-distributed-concurrency-and-messaging`) |\n| Retry without jitter | Thundering herd (§9 → `patterns-distributed-concurrency-and-messaging`) |\n| Retrying non-idempotent operations | Duplicates (§9 → `patterns-distributed-concurrency-and-messaging`) |\n| **Any network call without a timeout** | ⚠️ **The most under-set config in software** (§9 → `patterns-distributed-concurrency-and-messaging`) |\n| Unbounded producer-consumer queue | A memory leak hiding the real problem (§10 → `patterns-distributed-concurrency-and-messaging`) |\n| Double-checked locking by hand | Famously subtle; use the language's lazy init (§10 → `patterns-distributed-concurrency-and-messaging`) |\n| Promising exactly-once delivery | At-least-once + idempotency is the achievable target (§11 → `patterns-distributed-concurrency-and-messaging`) |\n| Event-carried state transfer by default | Couples consumers to your internal schema (§11 → `patterns-distributed-concurrency-and-messaging`) |\n| Agent where a workflow would do | ⚠️ **Prefer predefined code paths** (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n| Multi-agent for a single-agent task | Over-applied buzzword (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n| Agentic loop with no iteration cap | A financial failure mode (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n| Prompts embedded in orchestration code | Treat prompts as versioned artifacts (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n| Framework chosen before pattern | Backwards (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n| Big-bang rewrite | Use Strangler Fig (§13 → `patterns-llm-agentic-and-legacy-migration`) |\n| Schema change without expand-contract | The only safe way under live traffic (§13 → `patterns-llm-agentic-and-legacy-migration`) |\n| \"We might need this later\" | ⚠️ **The most expensive sentence in software** (§14) |\n\n---\n\n## §16. Contested Questions\n\n**16.1 Are GoF patterns obsolete?** §2 → `patterns-foundations-gof-and-alternatives` in full. **[CONTESTED, genuinely.** The \"patterns\nare C++ deficiencies\" claim is historically shaky given the Smalltalk origins; the\n\"patterns are timeless\" claim under-weights how much modern languages absorbed. **The\ndefensible position is per-pattern, not wholesale** — §3 → `patterns-foundations-gof-and-alternatives` audits them individually.]\n\n**16.2 Do patterns help or hurt juniors?** *Help*: shared vocabulary, exposure to\nconsidered designs, a path past reinventing. *Hurt*: **encourages installing patterns\nrather than solving problems**, and pattern-recognition becomes a proxy for judgment.\n**The teaching order that seems to work: forces first, then patterns as named responses,\nand never the catalogue first.**\n\n**16.3 OOP vs. functional vs. data-oriented?** All three have real domains. **The\nindustry has broadly moved toward composition over inheritance, immutability by default,\nand functions as first-class**, without abandoning objects. **⚠️ Treat strong advocacy in\nany direction as a signal of narrow exposure.**\n\n**16.4 Is Clean Architecture worth its cost?** *For*: testability, replaceable\ninfrastructure, findable business logic. *Against*: **file-count explosion, indirection,\nand genuine overkill for thin-domain applications.** Much of the criticism is really\ncriticism of applying it uniformly rather than of the idea.\n\n**16.5 Microservices — solved question or ongoing mistake?** The pendulum has swung toward\nmodular monoliths, and **\"microservices are an organizational solution adopted for\ntechnical-sounding reasons\"** is now a mainstream position rather than a contrarian one.\nStill genuinely right at sufficient organizational scale.\n\n**16.6 Is Event Sourcing worth it?** *For*: complete audit trail, temporal queries,\ndebugging by replay, and in some regulated domains it's a requirement. *Against*: §8 → `patterns-distributed-concurrency-and-messaging`'s\ncautionary case is representative rather than exceptional. **[CONTESTED, but the evidence\nleans toward \"less often than practitioners think.\"]**\n\n**16.7 Are the agentic patterns real patterns or vendor framing?** ⚠️ **Genuinely\nunresolved and worth holding loosely.** Some — workflow-vs-agent, human-in-the-loop,\nevaluator-optimizer, guardrails — describe forces that clearly recur. Others are framework\nmarketing with a pattern name attached. **Multiple competing taxonomies is what an\nimmature pattern language looks like**, and this one is two to three years old against\nGoF's decade of prior art.\n\n---\n\n## §17. Currency Snapshot — verified August 2026\n\n**[DURABLE] Most of this document doesn't move.** GoF is 1994, Fowler's *PoEAA* 2002,\nHohpe & Woolf 2003, Evans' *DDD* 2003 — and the forces they describe are unchanged.\nHere is what actually shifted.\n\n| Thing | Status as of Aug 2026 | Decay risk |\n|---|---|---|\n| **The GoF critique** | ⚠️ **Now mainstream rather than contrarian.** 2026 commentary describes a **\"post-pattern\" turn toward \"enlightened simplicity\"**, attributed to language maturation, FP, data-oriented design, and cognitive load theory. Counter-position remains live: patterns originated as much in **Smalltalk** (dynamic, first-class functions) as C++, so the \"C++ deficiency\" story is historically incomplete | Low |\n| **Absorbed patterns** | **Iterator, Singleton, Command, Strategy, Template Method** are largely language features or trivial in modern languages. **Modules act as natural singletons in Python and JS.** Frameworks (Spring, .NET, Angular) implement Factory\u002FProxy\u002FObserver implicitly — **you configure them rather than write them** | Low |\n| **Practitioner heuristic** | Widely-repeated 2026 framing: **\"Start simple. Add a pattern only when it removes duplication, isolates change, or clarifies intent. If introducing a pattern makes the code harder to explain, it is probably the wrong moment for it.\"** Composition over inheritance is the settled default | Low |\n| **Distributed data patterns** | **Outbox + Saga + CQRS (+ Event Sourcing) is the established production stack** for event-driven microservices. **Debezium\u002FCDC** for log-based publishing. ⚠️ **Dedicated workflow engines (Temporal, Watermill and similar) increasingly preferred over hand-rolled orchestration** | Medium |\n| **Saga guidance** | Published heuristic: **choreography for 2–3 steps, orchestration for 4+ or complex logic**. Choreography-plus-Postgres-outbox with a background relay is a common concrete pattern | Medium |\n| **⚠️ Event Sourcing caution** | Now widely stated rather than fringe: **event notification covers the majority of cases, CQRS most of the remainder, and Event Sourcing is for the minority where a full audit trail is a hard business requirement.** Documented failure case: a 3-junior team choosing full ES for a profile CRUD — **4 months for what should have taken 2 weeks, undebuggable state-reconstitution bugs, rewritten as REST in 3 weeks** | Low |\n| **⚠️ Circuit breaker adoption** | Survey work on microservice deployments found **circuit breaker notably less adopted than API gateway** — roughly half the usage — **which the researchers note weakens resilience** in exactly the systems that need it | Medium |\n| **⚠️ Agentic patterns** | **The live, unsettled pattern language.** At least three overlapping taxonomies in circulation (Ng's four, Anthropic's workflow patterns, and emergent reliability\u002Fmemory patterns from 2025–26). Core distinction — **workflows = predefined code paths; agents = model decides next step** — is stable and useful. Academic work is now presenting FM\u002Fagent patterns **in GoF format**. **ReAct predates the current framing by ~2 years.** Multi-agent widely described as a 2023–24 buzzword that is over-applied | **High** |\n| **Agentic operational practice** | **Prompts as versioned code**; step-level tracing with token-cost and guardrail-violation metrics (MLflow, LangSmith and similar); **iteration caps as a cost control**; **progressive disclosure against \"context rot\"** | **High** |\n\n**Goes stale fastest:** §12 → `patterns-llm-agentic-and-legacy-migration` entirely. **Essentially never stale:** §1 → `patterns-foundations-gof-and-alternatives`, §2 → `patterns-foundations-gof-and-alternatives`'s forces\nargument, §5 → `patterns-foundations-gof-and-alternatives`, §6.2 → `patterns-architectural`, §9 → `patterns-distributed-concurrency-and-messaging`, §13 → `patterns-llm-agentic-and-legacy-migration`, §14, §15.\n\n---\n\n## §18. The Canon\n\n### 18.1 Books\n\n| Author | Work | Why |\n|---|---|---|\n| **Gamma, Helm, Johnson & Vlissides** | ***Design Patterns*** (1994) | The original. ⚠️ **Read with §2 → `patterns-foundations-gof-and-alternatives` in hand** — it's a historical document with durable content, not a manual |\n| **Fowler** | ***Patterns of Enterprise Application Architecture*** (2002) | ⚠️ **Arguably more useful than GoF for most working engineers.** Repository, Unit of Work, Active Record, Data Mapper |\n| **Fowler** | *Refactoring* (2nd ed.) | The other half — how to get *to* a design, not just name it |\n| **Hohpe & Woolf** | ***Enterprise Integration Patterns*** (2003) | §11 → `patterns-distributed-concurrency-and-messaging`, and **the vocabulary is still standard 20+ years on** |\n| **Evans** | ***Domain-Driven Design*** (2003) | Dense. **Read Vernon's *Implementing DDD* or *DDD Distilled* first** |\n| **Nygard** | ***Release It!*** (2nd ed.) | ⚠️ **§9 → `patterns-distributed-concurrency-and-messaging`'s source, and the best book on production failure modes.** If you read one book here, consider this one |\n| **Richardson** | *Microservices Patterns* | §7–§8 → `patterns-architectural`, `patterns-distributed-concurrency-and-messaging`, and **microservices.io** is the free companion catalogue |\n| **Kleppmann** | *Designing Data-Intensive Applications* | The forces underneath §8 → `patterns-distributed-concurrency-and-messaging` |\n| **Newman** | *Building Microservices*; *Monolith to Microservices* | §7 → `patterns-architectural` and §13 → `patterns-llm-agentic-and-legacy-migration` |\n| **Feathers** | *Working Effectively with Legacy Code* | §13 → `patterns-llm-agentic-and-legacy-migration`, and still unmatched |\n| **Freeman & Robson** | *Head First Design Patterns* | **The most approachable way in.** Updated for modern Java |\n| **Ramalho** | *Fluent Python* | ⚠️ **Ch. 10, \"Design Patterns with First-Class Functions,\" is the single best demonstration of §4 → `patterns-foundations-gof-and-alternatives`'s argument** |\n| **Hunt & Thomas** | *The Pragmatic Programmer* | The judgment layer around all of it |\n| **Alexander** | *A Pattern Language* | Where the whole idea came from. Architecture, not software |\n\n### 18.2 Sites and people\n**refactoring.guru** (the best free pattern catalogue — clear diagrams, multi-language),\n**python-patterns.guide** (⚠️ **the sharpest published critique of GoF-in-a-modern-language**),\n**martinfowler.com** (bliki — the reference for most of this vocabulary),\n**microservices.io** (Chris Richardson's free catalogue for §7–§8 → `patterns-architectural`, `patterns-distributed-concurrency-and-messaging`),\n**Microsoft's Cloud Design Patterns** and **AWS Prescriptive Guidance** (solid, vendor-shaped),\n**c2.com wiki** (where the patterns community argued it out originally — still worth reading).\n\n**People**: **Martin Fowler**, **Kent Beck**, **Michael Nygard**, **Gregor Hohpe**,\n**Eric Evans** and **Vaughn Vernon**, **Sam Newman**, **Chris Richardson**,\n**Rich Hickey** (*Simple Made Easy* — ⚠️ **the best single talk on why simplicity beats\nfamiliarity**), **Sandi Metz** (OO design, and unusually good on when *not* to abstract),\n**Kevlin Henney**, **Ralph Johnson** (§1 → `patterns-foundations-gof-and-alternatives`'s quote).\n\n---\n\n## §19. Quick Reference\n\n### 19.1 Problem → pattern\n\n| Problem | Pattern |\n|---|---|\n| Their interface doesn't match mine | **Adapter** (§3.2 → `patterns-foundations-gof-and-alternatives`) |\n| Complex subsystem, simple need | Facade |\n| Layer behaviour composably | **Decorator** \u002F middleware |\n| Notify many of a change | Observer \u002F pub-sub |\n| Many optional construction params | Builder — ⚠️ **unless your language has named args** |\n| Behaviour varies by state | State (explicit machine) |\n| Operations over a stable type hierarchy | Visitor — ⚠️ **or pattern matching** (§4 → `patterns-foundations-gof-and-alternatives`) |\n| Swap an algorithm | ⚠️ **A function parameter** (§4 → `patterns-foundations-gof-and-alternatives`) |\n| Testable business logic | **Hexagonal \u002F ports and adapters** (§6.2 → `patterns-architectural`) |\n| Same word, different meanings across the business | **Bounded contexts** (§6.3 → `patterns-architectural`) |\n| Integrating a model I don't control | **Anti-Corruption Layer** (§7 → `patterns-architectural`) |\n| Write to DB *and* publish an event | ⚠️ **Transactional Outbox** (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Business operation spanning services | **Saga** — choreography ≤3 steps, else orchestration (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Reads and writes have different shapes | CQRS (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Full audit trail is a hard requirement | Event Sourcing — ⚠️ **and only then** (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Duplicate messages | Idempotent consumer \u002F inbox (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Downstream failing, don't cascade | **Circuit breaker** (§9 → `patterns-distributed-concurrency-and-messaging`) |\n| Transient failure | Retry with backoff **and jitter** (§9 → `patterns-distributed-concurrency-and-messaging`) |\n| One dependency shouldn't consume everything | Bulkhead (§9 → `patterns-distributed-concurrency-and-messaging`) |\n| Overloaded | Load shedding — ⚠️ **reject early, don't collapse** (§9 → `patterns-distributed-concurrency-and-messaging`) |\n| Replace a legacy system | **Strangler Fig** (§13 → `patterns-llm-agentic-and-legacy-migration`) |\n| Change a schema under live traffic | **Expand-contract** (§13 → `patterns-llm-agentic-and-legacy-migration`) |\n| Verify a migration | **Parallel run** (§13 → `patterns-llm-agentic-and-legacy-migration`) |\n| Multi-step LLM task | ⚠️ **A workflow, not an agent, if you can sequence it** (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n| LLM needs current or private data | RAG (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n| LLM output quality varies | Evaluator-optimizer with **separated roles** (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n| Agent could do something costly | **Human-in-the-loop gate + iteration cap** (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n\n### 19.2 Before adding a pattern\n- [ ] What **force** am I resolving? Can I state it in one sentence?\n- [ ] Does my language already have this as a feature? (§3 → `patterns-foundations-gof-and-alternatives`, §4 → `patterns-foundations-gof-and-alternatives`)\n- [ ] Do I have **two** cases, or am I speculating about the second?\n- [ ] Does this **remove duplication, isolate change, or clarify intent**?\n- [ ] Would a new team member find the code **easier** to explain, or harder?\n- [ ] What does it **cost** — and have I said that out loud?\n- [ ] Am I solving a problem, or demonstrating knowledge?\n\n---\n\n## §20. Sources and Method\n\n**Method.** Narrative review, written as **judgment guidance rather than a catalogue** —\nthe 23 GoF patterns are exhaustively documented for free elsewhere and reproducing them\nadds nothing. The durable material rests on the primary pattern literature (GoF, Fowler,\nHohpe & Woolf, Evans, Nygard) and on failure modes reported consistently across two\ndecades of practice. Three targeted searches were run in **August 2026** on the areas where\nthe picture could have moved: the current standing of the GoF critique, distributed-pattern\npractice, and the emerging agentic pattern language.\n\n**⚠️ A note on §2 → `patterns-foundations-gof-and-alternatives` and §16 specifically.** This is a domain with real, live disagreement\namong competent practitioners, and I have tried to **give each side its strongest form\nrather than adjudicate.** Where I take a position — §2.3 → `patterns-foundations-gof-and-alternatives`'s synthesis, §14's asymmetry\nargument — I've marked it as the position this document takes, not as consensus.\n\n**Search log** (August 2026): GoF relevance and critique in modern languages ·\ndistributed-system patterns (saga, outbox, circuit breaker, CQRS, event sourcing) in 2026\npractice · LLM and agentic design patterns and their taxonomies.\n\n**Primary and near-primary sources consulted (selected):**\n- **python-patterns.guide** for the sharpest form of the \"patterns as language\n  deficiencies\" argument; a **Microsoft archived blog post** and related commentary for the\n  Smalltalk-origins rebuttal; **Fluent Python** Ch. 10 (and Ralph Johnson's quote via its\n  epigraph); **Kansas State's CC 410 textbook** for the standard academic critique;\n  practitioner posts from 2026 for the \"post-pattern\"\u002Fenlightened-simplicity framing and\n  the start-simple heuristic\n- **microservices.io** (Chris Richardson) for the saga and outbox definitions; 2026\n  practitioner write-ups for the choreography\u002Forchestration step heuristic, the documented\n  order-loss and Event-Sourcing-for-CRUD cautionary cases, and the\n  event-notification\u002FCQRS\u002FES proportions; an academic survey of microservice architecture\n  patterns for the circuit-breaker adoption finding\n- **Anthropic's *Building Effective Agents*** framing (workflows vs. agents) as reported\n  in practitioner coverage; **Databricks' agent system design patterns** documentation;\n  **arXiv 2601.19752** on agentic design patterns as a system-theoretic framework, which\n  notes FM\u002Fagent patterns being presented in GoF format; 2026 pattern catalogues describing\n  the Ng \u002F Anthropic \u002F emergent taxonomy overlap\n\n**Confidence statement.** **High confidence** in §1 → `patterns-foundations-gof-and-alternatives`, §3–§7 → `patterns-foundations-gof-and-alternatives`, `patterns-architectural`, §9–§11 → `patterns-distributed-concurrency-and-messaging`, §13–§15 → `patterns-llm-agentic-and-legacy-migration` — these rest on\nthe primary pattern literature and long-stable practice rather than on anything searched.\n**High confidence** that the §2 → `patterns-foundations-gof-and-alternatives` debate exists in the form described, with **explicitly no\nposition on who is right**, because it is a values disagreement about cost and clarity that\nevidence does not settle. **Moderate confidence** in §8 → `patterns-distributed-concurrency-and-messaging`'s specific heuristics — the\nchoreography-vs-orchestration step counts and the event-notification\u002FCQRS\u002FES proportions\nare **practitioner rules of thumb from individual write-ups, not measured findings**, and\nshould be treated as starting points rather than thresholds. The cautionary cases in §8 → `patterns-distributed-concurrency-and-messaging` are\n**reported anecdotes**; I've included them because they're representative of a widely\ndescribed pattern of failure, not because any single one is authoritative. **Lower\nconfidence in §12 → `patterns-llm-agentic-and-legacy-migration`**, and deliberately so: the agentic pattern language is 2–3 years old,\nnaming is unstable, several sources are vendor-adjacent with obvious incentives, and\n**multiple competing taxonomies is exactly what an immature pattern language looks like** —\nwhich is why §16.7 leaves the \"real patterns or vendor framing\" question open rather than\nresolving it.\n","# Design Patterns: Anti-Patterns, Contested Questions, Currency, and Canon\n\n> **Part 5 of 5** of the *Design Patterns* reference (plugin `design-patterns`), covering §14–§20. Sibling skills: `patterns-foundations-gof-and-alternatives` (§0–§5), `patterns-architectural` (§6–§7), `patterns-distributed-concurrency-and-messaging` (§8–§11), `patterns-llm-agentic-and-legacy-migration` (§12–§13). Section numbers are shared across the set; a reference written as §N → `skill` points into that sibling skill.\n>\n> **Currency:** Verified August 2026. See §17 below for the currency snapshot and what goes stale first.\n\n> **How to read this.** Reference, not a catalogue. **The 23 GoF patterns are freely\n> available with diagrams and code samples everywhere** — this document does not reproduce\n> them. It addresses the harder questions: which ones still earn their keep, which ones\n> are artifacts of 1994's languages, what replaced them, where the genuinely useful\n> modern patterns live, and **when not to use any of them.**\n>\n> Three markers:\n> - **[DURABLE]** — design forces that recur regardless of language or era.\n> - **[VERSIONED]** — language features, framework practice, emerging pattern languages.\n> - **[CONTESTED]** — genuine disagreement, and **this domain has more of it than most.**\n>\n> **⚠️ GOTCHA** boxes mark where applying a pattern makes things worse.\n>\n> **The three framings that organize everything below:**\n> 1. **Patterns are a vocabulary, not a construction kit.** Their durable value is that\n>    \"this is a circuit breaker\" communicates a design in four words. **Their value was\n>    never that you should go looking for places to install them** — and treating the\n>    catalogue as a checklist is the single most damaging misreading of the entire\n>    literature (§14).\n> 2. **A pattern is a solution to a *force*, and the force is what's durable — not the\n>    implementation.** Many GoF implementations were workarounds for what C++ and Java\n>    couldn't express in 1994. **The forces persisted; the workarounds became language\n>    features** (§3 → `patterns-foundations-gof-and-alternatives`). Learn to see the force.\n> 3. **Over-application is the dominant failure mode, by a wide margin.** The cost of a\n>    missing pattern is some duplication you can refactor later. **The cost of an unneeded\n>    pattern is permanent indirection that every future reader must decode.** As one\n>    2026 practitioner framing puts it: add a pattern only when it removes duplication,\n>    isolates change, or clarifies intent — **and if introducing it makes the code harder\n>    to explain, it's the wrong moment for it.**\n\n---\n\n## §14. Anti-Patterns\n\n**[DURABLE] Naming these is at least as valuable as naming the patterns.**\n\n**Structural**: **God object \u002F god class**, **anemic domain model** (⚠️ **data-bags plus a\nservice layer — arguably the default outcome of layered architecture done carelessly**),\n**spaghetti**, **lasagna** (so many layers each adds nothing), **big ball of mud**,\n**circular dependencies**, **feature envy**, **shotgun surgery** (one change touches\nfifteen files).\n\n**Pattern-specific**: **Singleton abuse** (⚠️ **global mutable state with a design-pattern\nname on it** — hostile to testing, hides dependencies, causes ordering bugs), **Service\nLocator** (§5 → `patterns-foundations-gof-and-alternatives`), **the Poltergeist** (a class that exists only to call another),\n**BaseBean** (inheriting for convenience rather than for an is-a relationship),\n**over-abstracted factories**.\n\n**Process**: **premature optimization**, **premature generalization** (⚠️ **\"we might need\nthis later\" is the most expensive sentence in software**), **cargo cult architecture**\n(⚠️ **adopting Netflix's architecture at 1\u002F10000th of Netflix's scale**), **resume-driven\ndevelopment**, **the distributed monolith** (⚠️ **microservices that must deploy together —\nall the cost, none of the benefit, and the most common microservice failure mode**),\n**golden hammer**, **not-invented-here**, **stringly-typed** code, **magic numbers**,\n**boat anchor** (dead code kept \"just in case\"), **feature toggle debt**.\n\n> **⚠️ GOTCHA — pattern over-application, stated plainly, because it is the failure mode\n> this whole document exists to prevent.** Symptoms: interfaces with exactly one\n> implementation; factories that construct one type; three layers of indirection between\n> the caller and the work; class names ending in `Manager`, `Helper`, `Processor`, or\n> `AbstractProxyFactoryBean`; **you cannot find where anything actually happens.**\n>\n> **The asymmetry that should govern your default**: a missing pattern costs you some\n> duplication, which you can refactor when the third case appears and you can see the real\n> shape. **An unnecessary pattern costs every future reader permanently, and is far harder\n> to remove than to add.** When in doubt, don't.\n\n---\n\n## §15. Anti-Patterns Table\n\n| Anti-pattern | Why |\n|---|---|\n| Learning patterns as a catalogue to install | **\"Conformity to patterns is not a measure of goodness\"** — Ralph Johnson, GoF co-author (§1 → `patterns-foundations-gof-and-alternatives`) |\n| Adding a pattern that makes the code harder to explain | That's the signal it's premature (§2.3 → `patterns-foundations-gof-and-alternatives`) |\n| Hand-rolling Iterator in a language with iteration | ⚠️ The language is the pattern (§3.1 → `patterns-foundations-gof-and-alternatives`) |\n| Singleton for shared state | **Global mutable state with a nice name** (§14) |\n| Interface with exactly one implementation \"for testing\" | Modern test tooling fakes concrete types (§5 → `patterns-foundations-gof-and-alternatives`) |\n| Service Locator instead of DI | Hides dependencies rather than declaring them (§5 → `patterns-foundations-gof-and-alternatives`) |\n| Container magic you can't trace by reading | Runtime failures where compile-time ones belonged (§5 → `patterns-foundations-gof-and-alternatives`) |\n| Hexagonal architecture over a CRUD app | ⚠️ **If domain logic is thin, you don't need it** (§6.2 → `patterns-architectural`) |\n| Tactical DDD without the strategic work | Ceremony without the benefit (§6.3 → `patterns-architectural`) |\n| Microservices when teams aren't blocked on deploys | Paying the cost, not collecting the benefit (§7 → `patterns-architectural`) |\n| Microservices that must deploy together | ⚠️ **Distributed monolith** (§14) |\n| Adopting a hyperscaler's architecture at 1\u002F10000th the scale | Cargo cult (§14) |\n| Writing to your DB then publishing an event | ⚠️ **The dual-write problem. Real systems lose orders this way** (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Event Sourcing for CRUD | ⚠️ **Four months for a two-week feature, then rewritten** (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Choreographed saga past ~3 steps | Becomes impossible to reason about (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Treating compensation as rollback | The intermediate state was visible (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Synchronous external call with no circuit breaker | Cascading failure (§9 → `patterns-distributed-concurrency-and-messaging`) |\n| Retry without jitter | Thundering herd (§9 → `patterns-distributed-concurrency-and-messaging`) |\n| Retrying non-idempotent operations | Duplicates (§9 → `patterns-distributed-concurrency-and-messaging`) |\n| **Any network call without a timeout** | ⚠️ **The most under-set config in software** (§9 → `patterns-distributed-concurrency-and-messaging`) |\n| Unbounded producer-consumer queue | A memory leak hiding the real problem (§10 → `patterns-distributed-concurrency-and-messaging`) |\n| Double-checked locking by hand | Famously subtle; use the language's lazy init (§10 → `patterns-distributed-concurrency-and-messaging`) |\n| Promising exactly-once delivery | At-least-once + idempotency is the achievable target (§11 → `patterns-distributed-concurrency-and-messaging`) |\n| Event-carried state transfer by default | Couples consumers to your internal schema (§11 → `patterns-distributed-concurrency-and-messaging`) |\n| Agent where a workflow would do | ⚠️ **Prefer predefined code paths** (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n| Multi-agent for a single-agent task | Over-applied buzzword (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n| Agentic loop with no iteration cap | A financial failure mode (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n| Prompts embedded in orchestration code | Treat prompts as versioned artifacts (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n| Framework chosen before pattern | Backwards (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n| Big-bang rewrite | Use Strangler Fig (§13 → `patterns-llm-agentic-and-legacy-migration`) |\n| Schema change without expand-contract | The only safe way under live traffic (§13 → `patterns-llm-agentic-and-legacy-migration`) |\n| \"We might need this later\" | ⚠️ **The most expensive sentence in software** (§14) |\n\n---\n\n## §16. Contested Questions\n\n**16.1 Are GoF patterns obsolete?** §2 → `patterns-foundations-gof-and-alternatives` in full. **[CONTESTED, genuinely.** The \"patterns\nare C++ deficiencies\" claim is historically shaky given the Smalltalk origins; the\n\"patterns are timeless\" claim under-weights how much modern languages absorbed. **The\ndefensible position is per-pattern, not wholesale** — §3 → `patterns-foundations-gof-and-alternatives` audits them individually.]\n\n**16.2 Do patterns help or hurt juniors?** *Help*: shared vocabulary, exposure to\nconsidered designs, a path past reinventing. *Hurt*: **encourages installing patterns\nrather than solving problems**, and pattern-recognition becomes a proxy for judgment.\n**The teaching order that seems to work: forces first, then patterns as named responses,\nand never the catalogue first.**\n\n**16.3 OOP vs. functional vs. data-oriented?** All three have real domains. **The\nindustry has broadly moved toward composition over inheritance, immutability by default,\nand functions as first-class**, without abandoning objects. **⚠️ Treat strong advocacy in\nany direction as a signal of narrow exposure.**\n\n**16.4 Is Clean Architecture worth its cost?** *For*: testability, replaceable\ninfrastructure, findable business logic. *Against*: **file-count explosion, indirection,\nand genuine overkill for thin-domain applications.** Much of the criticism is really\ncriticism of applying it uniformly rather than of the idea.\n\n**16.5 Microservices — solved question or ongoing mistake?** The pendulum has swung toward\nmodular monoliths, and **\"microservices are an organizational solution adopted for\ntechnical-sounding reasons\"** is now a mainstream position rather than a contrarian one.\nStill genuinely right at sufficient organizational scale.\n\n**16.6 Is Event Sourcing worth it?** *For*: complete audit trail, temporal queries,\ndebugging by replay, and in some regulated domains it's a requirement. *Against*: §8 → `patterns-distributed-concurrency-and-messaging`'s\ncautionary case is representative rather than exceptional. **[CONTESTED, but the evidence\nleans toward \"less often than practitioners think.\"]**\n\n**16.7 Are the agentic patterns real patterns or vendor framing?** ⚠️ **Genuinely\nunresolved and worth holding loosely.** Some — workflow-vs-agent, human-in-the-loop,\nevaluator-optimizer, guardrails — describe forces that clearly recur. Others are framework\nmarketing with a pattern name attached. **Multiple competing taxonomies is what an\nimmature pattern language looks like**, and this one is two to three years old against\nGoF's decade of prior art.\n\n---\n\n## §17. Currency Snapshot — verified August 2026\n\n**[DURABLE] Most of this document doesn't move.** GoF is 1994, Fowler's *PoEAA* 2002,\nHohpe & Woolf 2003, Evans' *DDD* 2003 — and the forces they describe are unchanged.\nHere is what actually shifted.\n\n| Thing | Status as of Aug 2026 | Decay risk |\n|---|---|---|\n| **The GoF critique** | ⚠️ **Now mainstream rather than contrarian.** 2026 commentary describes a **\"post-pattern\" turn toward \"enlightened simplicity\"**, attributed to language maturation, FP, data-oriented design, and cognitive load theory. Counter-position remains live: patterns originated as much in **Smalltalk** (dynamic, first-class functions) as C++, so the \"C++ deficiency\" story is historically incomplete | Low |\n| **Absorbed patterns** | **Iterator, Singleton, Command, Strategy, Template Method** are largely language features or trivial in modern languages. **Modules act as natural singletons in Python and JS.** Frameworks (Spring, .NET, Angular) implement Factory\u002FProxy\u002FObserver implicitly — **you configure them rather than write them** | Low |\n| **Practitioner heuristic** | Widely-repeated 2026 framing: **\"Start simple. Add a pattern only when it removes duplication, isolates change, or clarifies intent. If introducing a pattern makes the code harder to explain, it is probably the wrong moment for it.\"** Composition over inheritance is the settled default | Low |\n| **Distributed data patterns** | **Outbox + Saga + CQRS (+ Event Sourcing) is the established production stack** for event-driven microservices. **Debezium\u002FCDC** for log-based publishing. ⚠️ **Dedicated workflow engines (Temporal, Watermill and similar) increasingly preferred over hand-rolled orchestration** | Medium |\n| **Saga guidance** | Published heuristic: **choreography for 2–3 steps, orchestration for 4+ or complex logic**. Choreography-plus-Postgres-outbox with a background relay is a common concrete pattern | Medium |\n| **⚠️ Event Sourcing caution** | Now widely stated rather than fringe: **event notification covers the majority of cases, CQRS most of the remainder, and Event Sourcing is for the minority where a full audit trail is a hard business requirement.** Documented failure case: a 3-junior team choosing full ES for a profile CRUD — **4 months for what should have taken 2 weeks, undebuggable state-reconstitution bugs, rewritten as REST in 3 weeks** | Low |\n| **⚠️ Circuit breaker adoption** | Survey work on microservice deployments found **circuit breaker notably less adopted than API gateway** — roughly half the usage — **which the researchers note weakens resilience** in exactly the systems that need it | Medium |\n| **⚠️ Agentic patterns** | **The live, unsettled pattern language.** At least three overlapping taxonomies in circulation (Ng's four, Anthropic's workflow patterns, and emergent reliability\u002Fmemory patterns from 2025–26). Core distinction — **workflows = predefined code paths; agents = model decides next step** — is stable and useful. Academic work is now presenting FM\u002Fagent patterns **in GoF format**. **ReAct predates the current framing by ~2 years.** Multi-agent widely described as a 2023–24 buzzword that is over-applied | **High** |\n| **Agentic operational practice** | **Prompts as versioned code**; step-level tracing with token-cost and guardrail-violation metrics (MLflow, LangSmith and similar); **iteration caps as a cost control**; **progressive disclosure against \"context rot\"** | **High** |\n\n**Goes stale fastest:** §12 → `patterns-llm-agentic-and-legacy-migration` entirely. **Essentially never stale:** §1 → `patterns-foundations-gof-and-alternatives`, §2 → `patterns-foundations-gof-and-alternatives`'s forces\nargument, §5 → `patterns-foundations-gof-and-alternatives`, §6.2 → `patterns-architectural`, §9 → `patterns-distributed-concurrency-and-messaging`, §13 → `patterns-llm-agentic-and-legacy-migration`, §14, §15.\n\n---\n\n## §18. The Canon\n\n### 18.1 Books\n\n| Author | Work | Why |\n|---|---|---|\n| **Gamma, Helm, Johnson & Vlissides** | ***Design Patterns*** (1994) | The original. ⚠️ **Read with §2 → `patterns-foundations-gof-and-alternatives` in hand** — it's a historical document with durable content, not a manual |\n| **Fowler** | ***Patterns of Enterprise Application Architecture*** (2002) | ⚠️ **Arguably more useful than GoF for most working engineers.** Repository, Unit of Work, Active Record, Data Mapper |\n| **Fowler** | *Refactoring* (2nd ed.) | The other half — how to get *to* a design, not just name it |\n| **Hohpe & Woolf** | ***Enterprise Integration Patterns*** (2003) | §11 → `patterns-distributed-concurrency-and-messaging`, and **the vocabulary is still standard 20+ years on** |\n| **Evans** | ***Domain-Driven Design*** (2003) | Dense. **Read Vernon's *Implementing DDD* or *DDD Distilled* first** |\n| **Nygard** | ***Release It!*** (2nd ed.) | ⚠️ **§9 → `patterns-distributed-concurrency-and-messaging`'s source, and the best book on production failure modes.** If you read one book here, consider this one |\n| **Richardson** | *Microservices Patterns* | §7–§8 → `patterns-architectural`, `patterns-distributed-concurrency-and-messaging`, and **microservices.io** is the free companion catalogue |\n| **Kleppmann** | *Designing Data-Intensive Applications* | The forces underneath §8 → `patterns-distributed-concurrency-and-messaging` |\n| **Newman** | *Building Microservices*; *Monolith to Microservices* | §7 → `patterns-architectural` and §13 → `patterns-llm-agentic-and-legacy-migration` |\n| **Feathers** | *Working Effectively with Legacy Code* | §13 → `patterns-llm-agentic-and-legacy-migration`, and still unmatched |\n| **Freeman & Robson** | *Head First Design Patterns* | **The most approachable way in.** Updated for modern Java |\n| **Ramalho** | *Fluent Python* | ⚠️ **Ch. 10, \"Design Patterns with First-Class Functions,\" is the single best demonstration of §4 → `patterns-foundations-gof-and-alternatives`'s argument** |\n| **Hunt & Thomas** | *The Pragmatic Programmer* | The judgment layer around all of it |\n| **Alexander** | *A Pattern Language* | Where the whole idea came from. Architecture, not software |\n\n### 18.2 Sites and people\n**refactoring.guru** (the best free pattern catalogue — clear diagrams, multi-language),\n**python-patterns.guide** (⚠️ **the sharpest published critique of GoF-in-a-modern-language**),\n**martinfowler.com** (bliki — the reference for most of this vocabulary),\n**microservices.io** (Chris Richardson's free catalogue for §7–§8 → `patterns-architectural`, `patterns-distributed-concurrency-and-messaging`),\n**Microsoft's Cloud Design Patterns** and **AWS Prescriptive Guidance** (solid, vendor-shaped),\n**c2.com wiki** (where the patterns community argued it out originally — still worth reading).\n\n**People**: **Martin Fowler**, **Kent Beck**, **Michael Nygard**, **Gregor Hohpe**,\n**Eric Evans** and **Vaughn Vernon**, **Sam Newman**, **Chris Richardson**,\n**Rich Hickey** (*Simple Made Easy* — ⚠️ **the best single talk on why simplicity beats\nfamiliarity**), **Sandi Metz** (OO design, and unusually good on when *not* to abstract),\n**Kevlin Henney**, **Ralph Johnson** (§1 → `patterns-foundations-gof-and-alternatives`'s quote).\n\n---\n\n## §19. Quick Reference\n\n### 19.1 Problem → pattern\n\n| Problem | Pattern |\n|---|---|\n| Their interface doesn't match mine | **Adapter** (§3.2 → `patterns-foundations-gof-and-alternatives`) |\n| Complex subsystem, simple need | Facade |\n| Layer behaviour composably | **Decorator** \u002F middleware |\n| Notify many of a change | Observer \u002F pub-sub |\n| Many optional construction params | Builder — ⚠️ **unless your language has named args** |\n| Behaviour varies by state | State (explicit machine) |\n| Operations over a stable type hierarchy | Visitor — ⚠️ **or pattern matching** (§4 → `patterns-foundations-gof-and-alternatives`) |\n| Swap an algorithm | ⚠️ **A function parameter** (§4 → `patterns-foundations-gof-and-alternatives`) |\n| Testable business logic | **Hexagonal \u002F ports and adapters** (§6.2 → `patterns-architectural`) |\n| Same word, different meanings across the business | **Bounded contexts** (§6.3 → `patterns-architectural`) |\n| Integrating a model I don't control | **Anti-Corruption Layer** (§7 → `patterns-architectural`) |\n| Write to DB *and* publish an event | ⚠️ **Transactional Outbox** (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Business operation spanning services | **Saga** — choreography ≤3 steps, else orchestration (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Reads and writes have different shapes | CQRS (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Full audit trail is a hard requirement | Event Sourcing — ⚠️ **and only then** (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Duplicate messages | Idempotent consumer \u002F inbox (§8 → `patterns-distributed-concurrency-and-messaging`) |\n| Downstream failing, don't cascade | **Circuit breaker** (§9 → `patterns-distributed-concurrency-and-messaging`) |\n| Transient failure | Retry with backoff **and jitter** (§9 → `patterns-distributed-concurrency-and-messaging`) |\n| One dependency shouldn't consume everything | Bulkhead (§9 → `patterns-distributed-concurrency-and-messaging`) |\n| Overloaded | Load shedding — ⚠️ **reject early, don't collapse** (§9 → `patterns-distributed-concurrency-and-messaging`) |\n| Replace a legacy system | **Strangler Fig** (§13 → `patterns-llm-agentic-and-legacy-migration`) |\n| Change a schema under live traffic | **Expand-contract** (§13 → `patterns-llm-agentic-and-legacy-migration`) |\n| Verify a migration | **Parallel run** (§13 → `patterns-llm-agentic-and-legacy-migration`) |\n| Multi-step LLM task | ⚠️ **A workflow, not an agent, if you can sequence it** (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n| LLM needs current or private data | RAG (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n| LLM output quality varies | Evaluator-optimizer with **separated roles** (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n| Agent could do something costly | **Human-in-the-loop gate + iteration cap** (§12 → `patterns-llm-agentic-and-legacy-migration`) |\n\n### 19.2 Before adding a pattern\n- [ ] What **force** am I resolving? Can I state it in one sentence?\n- [ ] Does my language already have this as a feature? (§3 → `patterns-foundations-gof-and-alternatives`, §4 → `patterns-foundations-gof-and-alternatives`)\n- [ ] Do I have **two** cases, or am I speculating about the second?\n- [ ] Does this **remove duplication, isolate change, or clarify intent**?\n- [ ] Would a new team member find the code **easier** to explain, or harder?\n- [ ] What does it **cost** — and have I said that out loud?\n- [ ] Am I solving a problem, or demonstrating knowledge?\n\n---\n\n## §20. Sources and Method\n\n**Method.** Narrative review, written as **judgment guidance rather than a catalogue** —\nthe 23 GoF patterns are exhaustively documented for free elsewhere and reproducing them\nadds nothing. The durable material rests on the primary pattern literature (GoF, Fowler,\nHohpe & Woolf, Evans, Nygard) and on failure modes reported consistently across two\ndecades of practice. Three targeted searches were run in **August 2026** on the areas where\nthe picture could have moved: the current standing of the GoF critique, distributed-pattern\npractice, and the emerging agentic pattern language.\n\n**⚠️ A note on §2 → `patterns-foundations-gof-and-alternatives` and §16 specifically.** This is a domain with real, live disagreement\namong competent practitioners, and I have tried to **give each side its strongest form\nrather than adjudicate.** Where I take a position — §2.3 → `patterns-foundations-gof-and-alternatives`'s synthesis, §14's asymmetry\nargument — I've marked it as the position this document takes, not as consensus.\n\n**Search log** (August 2026): GoF relevance and critique in modern languages ·\ndistributed-system patterns (saga, outbox, circuit breaker, CQRS, event sourcing) in 2026\npractice · LLM and agentic design patterns and their taxonomies.\n\n**Primary and near-primary sources consulted (selected):**\n- **python-patterns.guide** for the sharpest form of the \"patterns as language\n  deficiencies\" argument; a **Microsoft archived blog post** and related commentary for the\n  Smalltalk-origins rebuttal; **Fluent Python** Ch. 10 (and Ralph Johnson's quote via its\n  epigraph); **Kansas State's CC 410 textbook** for the standard academic critique;\n  practitioner posts from 2026 for the \"post-pattern\"\u002Fenlightened-simplicity framing and\n  the start-simple heuristic\n- **microservices.io** (Chris Richardson) for the saga and outbox definitions; 2026\n  practitioner write-ups for the choreography\u002Forchestration step heuristic, the documented\n  order-loss and Event-Sourcing-for-CRUD cautionary cases, and the\n  event-notification\u002FCQRS\u002FES proportions; an academic survey of microservice architecture\n  patterns for the circuit-breaker adoption finding\n- **Anthropic's *Building Effective Agents*** framing (workflows vs. agents) as reported\n  in practitioner coverage; **Databricks' agent system design patterns** documentation;\n  **arXiv 2601.19752** on agentic design patterns as a system-theoretic framework, which\n  notes FM\u002Fagent patterns being presented in GoF format; 2026 pattern catalogues describing\n  the Ng \u002F Anthropic \u002F emergent taxonomy overlap\n\n**Confidence statement.** **High confidence** in §1 → `patterns-foundations-gof-and-alternatives`, §3–§7 → `patterns-foundations-gof-and-alternatives`, `patterns-architectural`, §9–§11 → `patterns-distributed-concurrency-and-messaging`, §13–§15 → `patterns-llm-agentic-and-legacy-migration` — these rest on\nthe primary pattern literature and long-stable practice rather than on anything searched.\n**High confidence** that the §2 → `patterns-foundations-gof-and-alternatives` debate exists in the form described, with **explicitly no\nposition on who is right**, because it is a values disagreement about cost and clarity that\nevidence does not settle. **Moderate confidence** in §8 → `patterns-distributed-concurrency-and-messaging`'s specific heuristics — the\nchoreography-vs-orchestration step counts and the event-notification\u002FCQRS\u002FES proportions\nare **practitioner rules of thumb from individual write-ups, not measured findings**, and\nshould be treated as starting points rather than thresholds. The cautionary cases in §8 → `patterns-distributed-concurrency-and-messaging` are\n**reported anecdotes**; I've included them because they're representative of a widely\ndescribed pattern of failure, not because any single one is authoritative. **Lower\nconfidence in §12 → `patterns-llm-agentic-and-legacy-migration`**, and deliberately so: the agentic pattern language is 2–3 years old,\nnaming is unstable, several sources are vendor-adjacent with obvious incentives, and\n**multiple competing taxonomies is exactly what an immature pattern language looks like** —\nwhich is why §16.7 leaves the \"real patterns or vendor framing\" question open rather than\nresolving it.\n",{"name":5,"description":7},"develop","ae32736a1aabddabca5d2c96d665aa0ebc7d8700","src\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fdesign-patterns\u002Fskills\u002Fpatterns-reference",3,"https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey","https:\u002F\u002Fthe-vibey-project.github.io\u002Fvibey\u002F","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project","https:\u002F\u002Fvibewithadam.matthewsteinberger.com","freedom for software engineers","2026-11-15 05:47:42",{"source":8,"skillName":5,"commands":35,"prompt":45,"zipAvailable":46},[36,39,42],{"tool":37,"command":38},"npx","npx skills add the-vibey-project\u002Fvibey --skill patterns-reference",{"tool":40,"command":41},"bunx","bunx skills add the-vibey-project\u002Fvibey --skill patterns-reference",{"tool":43,"command":44},"pnpm","pnpm dlx skills add the-vibey-project\u002Fvibey --skill patterns-reference","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fdesign-patterns\u002Fskills\u002Fpatterns-reference\u002FSKILL.md",true,[],[49,56,63,70,77,84],{"skillNo":50,"name":51,"nameZh":6,"description":52,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":53,"categories":54,"keywords":55,"publishedAt":19},"01M7AT1FQJAE1FQYAMDTF490Y4","white-paper-writing","Use when writing white papers, technical reports, policy documents, thought leadership pieces, or any long-form authoritative document. Triggers on requests to write, structure, outline, or review white papers, technical reports, position papers, policy briefs, or evidence-driven arguments. Also use for B2B content marketing strategy, technical documentation requiring authority, academic-style reports, or any document that must educate while persuading. Use when someone asks \"how should I structure this\" for a long-form document.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Fwhite-paper-writing\u002FSKILL.md",[],[],{"skillNo":57,"name":58,"nameZh":6,"description":59,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":60,"categories":61,"keywords":62,"publishedAt":19},"01M7AT16BJRJJKK2MASXRZS76G","prose-technical-mechanics","Use when editing or writing prose at a technical\u002Fmechanical level: choosing between Anglo-Saxon and Latinate diction, placing information in topic vs stress positions, writing periodic vs cumulative sentences, handling sentence rhythm, punctuation as logic, transitions, paragraph structure, or phonesthetics. Use when someone wants to understand WHY prose works or doesn't, not just surface-level style advice. Triggers on word choice, sentence structure, emphasis, rhythm, diction, or any deep writing mechanics question.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Fprose-technical-mechanics\u002FSKILL.md",[],[],{"skillNo":64,"name":65,"nameZh":6,"description":66,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":67,"categories":68,"keywords":69,"publishedAt":19},"01M7AT0W9HT0ZZ9Y287NW99MR3","prose-mechanics","Use when writing, editing, or analyzing prose style; when trying to avoid generic AI-sounding writing; when applying specific prose styles such as journalistic, academic, narrative, KJV biblical, Hemingway plain, Latinate\u002FJamesian, Orwellian, Augustan, Victorian, Early Modern (Bacon, Browne, Milton), or free indirect discourse; or when coaching someone on writing voice and mechanics. Triggers on any request to improve, analyze, or write in a specific prose style, to fix \"AI-sounding\" writing, to make prose more vivid or concrete, to vary sentence rhythm, or to understand how a particular writer achieves their effects.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Fprose-mechanics\u002FSKILL.md",[],[],{"skillNo":71,"name":72,"nameZh":6,"description":73,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":74,"categories":75,"keywords":76,"publishedAt":19},"01M7AT0KR635JX66X2X6F3E2CP","narrative-structure","Use when structuring stories, pitches, presentations, white papers, or any persuasive narrative; analyzing the hero's journey in fiction or non-fiction; applying StoryBrand for business communication; designing narrative arcs for thought leadership; or understanding Vogler, Snyder, Propp, or Campbell frameworks. Triggers on any narrative structure, storytelling, pitch structure, StoryBrand, hero's journey, three-act structure, Freytag, Save the Cat, narrative arc, or \"how should I structure this story\u002Fpitch\u002Fpresentation\" request.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Fnarrative-structure\u002FSKILL.md",[],[],{"skillNo":78,"name":79,"nameZh":6,"description":80,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":81,"categories":82,"keywords":83,"publishedAt":19},"01M7AT0AKGW09NKKZDYBT8VRDE","legal-brief-writing","Use when writing legal briefs, motions, or any court filing; when analyzing judicial cognition and persuasion; when applying elite brief-writing techniques from Roberts, Clement, Kagan, Garner; or when structuring legal arguments for maximum persuasion. Also use for autistic\u002Fneurodivergent advocates who need to understand how their natural communication style maps to elite legal advocacy. Triggers on any legal writing, brief drafting, motion preparation, or legal argument structuring request.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Flegal-brief-writing\u002FSKILL.md",[],[],{"skillNo":85,"name":86,"nameZh":6,"description":87,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":88,"categories":89,"keywords":90,"publishedAt":19},"01M7AT00VWPS4Q8B5VEMXX9NQT","journal-publishability-criteria","Use whenever a research paper, article or preprint is being written, revised, reviewed or published, and specifically before every publication of docs\u002Fpaper.md. Covers what legitimate journals actually gate on, in order of gating — the editor's desk screen (scope, novelty, package problems), what reviewers judge (methodological soundness, claims the evidence can carry, statistical and qualitative reporting), EQUATOR reporting guidelines, the ICMJE authorship criteria, COPE's view of text recycling, the near-universal generative-AI policy (no AI author, disclosure, author responsibility), TOP 2025 transparency standards, how to verify a journal is legitimate, submitting without an institution, and a pre-submission checklist. Triggers on requests to evaluate, review, prepare or submit a paper, to judge publishability, to write a declarations or data-availability section, to disclose AI use, or to check a journal.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Fjournal-publishability-criteria\u002FSKILL.md",[],[]]