# Encyclopedia of Agentic Coding Patterns > A maintained pattern language for building software with AI agents — for the practitioners who build with them and the leads who direct them. This is the Encyclopedia of Agentic Coding Patterns, curated by Wolf McNally. It collects 263 articles organized as a pattern language across 14 sections. Updated 2026-05-25. Canonical URL: https://aipatternbook.com/. Append `.md` to any article URL below for a clean Markdown copy (e.g. https://aipatternbook.com/.md). ## Introduction - [What's New](https://aipatternbook.com/whats-new): A running log of recent additions, edits, and structural changes to the encyclopedia, newest first. - [Pattern Map](https://aipatternbook.com/pattern-map): An interactive graph of every pattern, concept, and antipattern in the encyclopedia and how they connect through their Related Patterns links. - [Welcome](https://aipatternbook.com/welcome): Why the knowledge behind good software matters more, not less, once agents write the code, and what skill replaces typing it yourself. (draft — not yet reviewed) - [What Is Agentic Coding?](https://aipatternbook.com/what-is-agentic-coding): What separates an agent from autocomplete and chat, the three capabilities that made it possible, and what your job becomes once the agent writes the code. (draft — not yet reviewed) - [What Are Design Patterns?](https://aipatternbook.com/what-are-design-patterns): Where the pattern-language idea came from, from Alexander's buildings to the Gang of Four's code, and why named patterns earn their keep when you direct an agent. (draft — not yet reviewed) - [How to Read This Book](https://aipatternbook.com/how-to-read-this-book): Five reading tracks and a guide to the entry structure, so you can navigate the encyclopedia by situation rather than front to back. (draft — not yet reviewed) - [How This Book Writes Itself](https://aipatternbook.com/methodology): How the Bartley engine researches, writes, edits, and deploys this book in a continuous loop, rewriting its own process based on what it observes. (draft — not yet reviewed) ## Product Judgment and What to Create - [Problem](https://aipatternbook.com/problem): A real unmet need, friction, risk, or desire experienced by a specific person or organization, the foundation every product decision depends on. (draft — not yet reviewed) - [Customer](https://aipatternbook.com/customer): The person or organization that pays, approves, or otherwise causes the product to exist, distinct from the user who uses it. (draft — not yet reviewed) - [User](https://aipatternbook.com/user): The person whose workflow, pain, or desire the product directly touches, whose continued use is what sustains the product over time. (draft — not yet reviewed) - [Value Proposition](https://aipatternbook.com/value-proposition): The reason a specific customer should choose your product over doing nothing, building it themselves, or picking an alternative. (draft — not yet reviewed) - [Competitive Landscape](https://aipatternbook.com/competitive-landscape): The set of real alternatives a customer has, including direct rivals, indirect substitutes, and the ever-present option of doing nothing. (draft — not yet reviewed) - [Differentiation](https://aipatternbook.com/differentiation): Being distinct in a way that matters to the customer and is hard for competitors to copy, not different for its own sake. (draft — not yet reviewed) - [Beachhead](https://aipatternbook.com/beachhead): The narrow initial market or use case where a product can win first: a small, defensible territory that serves as a base for expansion. (draft — not yet reviewed) - [Go-to-Market](https://aipatternbook.com/go-to-market): The plan by which a product reaches customers, gets adopted, and starts generating revenue, the bridge between building it and people using it. (draft — not yet reviewed) - [Revenue Model](https://aipatternbook.com/revenue-model): The basic structure by which money flows into the business, answering what you're selling, distinct from how you collect it. (draft — not yet reviewed) - [Monetization](https://aipatternbook.com/monetization): The practical mechanism that converts product usage into revenue: pricing tiers, payment flows, upgrade prompts, and conversion triggers. (draft — not yet reviewed) - [Distribution](https://aipatternbook.com/distribution): The channels, partnerships, and mechanisms through which potential customers discover, evaluate, and access a product. (draft — not yet reviewed) - [Product-Market Fit](https://aipatternbook.com/product-market-fit): The emergent condition in which a product clearly satisfies a strong market need, the inflection point where a team stops searching and starts executing. (draft — not yet reviewed) - [Crossing the Chasm](https://aipatternbook.com/crossing-the-chasm): The dangerous gap between early adopters and the early majority, where a product can thrive among enthusiasts yet die before reaching the mainstream. (draft — not yet reviewed) - [Zero to One](https://aipatternbook.com/zero-to-one): Creating something genuinely new, a product or category that didn't exist before, as opposed to competing within an established market. (draft — not yet reviewed) - [Bottleneck](https://aipatternbook.com/bottleneck): The single constraint that limits a system's overall throughput more than any other, naming where the real limit lives. (draft — not yet reviewed) - [Roadmap](https://aipatternbook.com/roadmap): An ordered view of intended product evolution: what the team plans to build, in what sequence, and roughly when. (draft — not yet reviewed) - [User Story](https://aipatternbook.com/user-story): A concise statement of desired user-centered behavior that bridges product strategy and implementation in language the whole team can act on. (draft — not yet reviewed) - [Use Case](https://aipatternbook.com/use-case): A step-by-step account of how a user achieves a goal with the system, including preconditions, the main flow, and alternative paths. (draft — not yet reviewed) - [Build-vs-Don't-Build Judgment](https://aipatternbook.com/build-vs-dont-build-judgment): The discipline of evaluating whether a product, feature, or project should exist at all, the gate every roadmap item passes through. (draft — not yet reviewed) ## Intent, Scope, and Decision-Making - [Application](https://aipatternbook.com/application): The thing you're building, named clearly enough that everything downstream, requirements, architecture, testing, can hang off it. (draft — not yet reviewed) - [Brief](https://aipatternbook.com/brief): A short, frame-setting document naming what you're building, who it's for, what matters most, and what success looks like, before any spec or plan exists. (draft — not yet reviewed) - [Requirement](https://aipatternbook.com/requirement): A description of what the application must do or what properties it must have, the basis everything else is built and verified against. (draft — not yet reviewed) - [Constraint](https://aipatternbook.com/constraint): A limit the design must respect, time, budget, platform, regulation, distinct from requirements, which describe what the system must do. (draft — not yet reviewed) - [Acceptance Criteria](https://aipatternbook.com/acceptance-criteria): The concrete, checkable conditions that decide whether a requirement is actually met, turning "it works" into a verifiable claim. (draft — not yet reviewed) - [Specification](https://aipatternbook.com/specification): A written description of what a system should do, precise enough to build from and concrete enough to verify. (draft — not yet reviewed) - [Spec-Driven Development](https://aipatternbook.com/spec-driven-development): A workflow where a written specification is the primary artifact, and implementation, review, and evolution organize around that document. (draft — not yet reviewed) - [Design Doc](https://aipatternbook.com/design-doc): Translates requirements into a technical plan, the bridge between knowing what to build and deciding how to build it. (draft — not yet reviewed) - [Tradeoff](https://aipatternbook.com/tradeoff): A choice where improving one property costs you another, and naming it forces the conflict into the open before code locks the decision in. (draft — not yet reviewed) - [Judgment](https://aipatternbook.com/judgment): Weighing incomplete evidence to choose a course good enough to move forward, the human contribution agents cannot supply for themselves. (draft — not yet reviewed) - [Taste](https://aipatternbook.com/taste): The ability to recognize what is good, the companion to judgment's ability to choose well. (draft — not yet reviewed) - [Architecture Decision Record](https://aipatternbook.com/architecture-decision-record): A short record of one design decision, its context, options, choice, and reasoning, so future readers don't have to guess why the system is built this way. (draft — not yet reviewed) ## Structure and Decomposition - [Architecture](https://aipatternbook.com/architecture): The large-scale shape of a system, its major components, how data flows between them, and the reasoning behind those choices. (draft — not yet reviewed) - [Shape](https://aipatternbook.com/shape): The structural form of an artifact as perceived at a level of observation, what you see when you step back and squint at a system. (draft — not yet reviewed) - [Abstraction](https://aipatternbook.com/abstraction): The tool that lets you ignore what doesn't matter right now so you can focus on what does, by hiding detail behind a simpler surface. (draft — not yet reviewed) - [Component](https://aipatternbook.com/component): A bounded piece of a larger system with a defined role and an explicit interface, the noun in the sentence that describes your architecture. (draft — not yet reviewed) - [Module](https://aipatternbook.com/module): A unit of code grouped around a single coherent responsibility, bridging the system's large-scale structure and the functions that do the work. (draft — not yet reviewed) - [Interface](https://aipatternbook.com/interface): The surface where two parts of a system meet: the operations, inputs, outputs, and expectations through which one thing uses another. (draft — not yet reviewed) - [Consumer](https://aipatternbook.com/consumer): The code, person, system, or agent on the other side of an interface, whose identity and needs shape every structural decision you make. (draft — not yet reviewed) - [Contract](https://aipatternbook.com/contract): The explicit or implicit promise about what will happen across an interface, the agreement that holds components together. (draft — not yet reviewed) - [Boundary](https://aipatternbook.com/boundary): The line that separates one part of a system from another, letting a team reason about what's inside, what's outside, and what must hold at the crossing. (draft — not yet reviewed) - [Cohesion](https://aipatternbook.com/cohesion): The degree to which the contents of a module belong together, distinguishing a module with a clear purpose from a grab bag. (draft — not yet reviewed) - [Coupling](https://aipatternbook.com/coupling): The degree to which one part of a system depends on another, letting a team reason about whether a change in one place will be felt in another. (draft — not yet reviewed) - [Dependency](https://aipatternbook.com/dependency): Anything one part of a system needs from another to do its work, and the maintenance promise a team accepts when it chooses to rely on it. (draft — not yet reviewed) - [Composition](https://aipatternbook.com/composition): Combining smaller, simpler parts into something larger and more capable, building small things that snap together rather than one big thing. (draft — not yet reviewed) - [Separation of Concerns](https://aipatternbook.com/separation-of-concerns): Organizing a system so each part addresses exactly one reason to change, keeping unrelated concerns from tangling together. (draft — not yet reviewed) - [Monolith](https://aipatternbook.com/monolith): A system built, deployed, and evolved as a single unified unit, a structural choice with real tradeoffs, not the same as a mess. (draft — not yet reviewed) - [Decomposition](https://aipatternbook.com/decomposition): Dividing a larger system into smaller, more manageable pieces, where the choice of where to cut shapes everything that follows. (draft — not yet reviewed) - [Task Decomposition](https://aipatternbook.com/task-decomposition): Breaking a larger goal into bounded units of work with clear acceptance criteria, the practice that directly shapes the quality of an agent's output. (draft — not yet reviewed) - [Big Ball of Mud](https://aipatternbook.com/big-ball-of-mud): Each shortcut feels locally rational until the cumulative effect is a system where no one can change one part without breaking another. (draft — not yet reviewed) - [Spaghetti Code](https://aipatternbook.com/spaghetti-code): Letting control flow twist through a module until nobody can follow what happens next. (draft — not yet reviewed) - [God Object](https://aipatternbook.com/god-object): Centralizing too many responsibilities in one class, module, or service until every change must pass through it. (draft — not yet reviewed) ## Data, State, and Truth - [Data Model](https://aipatternbook.com/data-model): The conceptual inventory of what a system knows: the nouns, their attributes, and how they connect, named once for every layer to agree on. (draft — not yet reviewed) - [Schema (Database)](https://aipatternbook.com/schema-database): The data model rendered as a contract the database enforces: the columns, types, keys, and constraints the storage engine will accept. (draft — not yet reviewed) - [Schema (Serialization)](https://aipatternbook.com/schema-serialization): The contract for what shape data takes as it crosses a boundary: which fields are present, what types they carry, and what evolution is permitted. (draft — not yet reviewed) - [Data Structure](https://aipatternbook.com/data-structure): The in-memory arrangement of values that decides which of a program's operations are cheap and which are expensive. (draft — not yet reviewed) - [State](https://aipatternbook.com/state): The information a system remembers between operations, naming where that memory lives, how long it lasts, and who can change it. (draft — not yet reviewed) - [Artifact](https://aipatternbook.com/artifact): A durable, named, inspectable product of work, a thing you can reference after the moment that made it. (draft — not yet reviewed) - [Source of Truth](https://aipatternbook.com/source-of-truth): The single authoritative location for a piece of state, so that when copies disagree, everyone knows which one is right. (draft — not yet reviewed) - [DRY (Don't Repeat Yourself)](https://aipatternbook.com/dry): The principle that each piece of knowledge should have one authoritative home, because duplicated knowledge drifts out of sync as the system evolves. (draft — not yet reviewed) - [Copy-Paste Programming](https://aipatternbook.com/copy-paste-programming): Duplicating code or rules instead of giving shared knowledge one explicit home. (draft — not yet reviewed) - [Hard Coding](https://aipatternbook.com/hard-coding): Embedding values directly in source code that should live somewhere a reader, operator, or future agent can change them. (draft — not yet reviewed) - [Primitive Obsession](https://aipatternbook.com/primitive-obsession): Using raw strings, integers, booleans, or loose maps where a named domain type would carry the meaning and enforce the rules. (draft — not yet reviewed) - [Data Normalization / Denormalization](https://aipatternbook.com/data-normalization): Organizing data so each fact lives in one place (normalization) or deliberately duplicating it for speed (denormalization), and when each pays off. (draft — not yet reviewed) - [Database](https://aipatternbook.com/database): A system that stores data persistently so it survives restarts, crashes, and hardware failures, shaping what your application can do and how fast. (draft — not yet reviewed) - [CRUD](https://aipatternbook.com/crud): The four basic operations on stored data, create, read, update, and delete, the vocabulary for most database interactions. (draft — not yet reviewed) - [Consistency](https://aipatternbook.com/consistency): The property that everyone reading a system's data sees a story that adds up, naming which kind of "adds up" a team actually needs. (draft — not yet reviewed) - [Atomic](https://aipatternbook.com/atomic): An operation that either fully completes or has no effect at all, never leaving observable state half-finished. (draft — not yet reviewed) - [Transaction](https://aipatternbook.com/transaction): A group of operations that succeed or fail together as one unit, protecting state from corruption during multi-step changes. (draft — not yet reviewed) - [Serialization](https://aipatternbook.com/serialization): Converting an in-memory data structure into a portable format for storage or transmission, and reconstructing it on the other side. (draft — not yet reviewed) - [Idempotency](https://aipatternbook.com/idempotency): The property that applying an operation more than once has the same effect as applying it once, making retries and duplicates safe. (draft — not yet reviewed) - [Domain Model](https://aipatternbook.com/domain-model): Captures the concepts, rules, and relationships of a business problem in a form both humans and software can reason about. (draft — not yet reviewed) - [Entity](https://aipatternbook.com/entity): A thing in your domain with a distinct identity that persists through change and can be told apart from every other thing of its kind. (draft — not yet reviewed) - [Value Object](https://aipatternbook.com/value-object): An object defined entirely by its attributes, with no identity of its own; two value objects with the same data are the same thing. (draft — not yet reviewed) - [Ubiquitous Language](https://aipatternbook.com/ubiquitous-language): A shared vocabulary drawn from the business domain that every participant uses consistently in conversation, documentation, and code. (draft — not yet reviewed) - [Naming](https://aipatternbook.com/naming): Choosing identifiers for concepts, variables, functions, and files so code communicates its intent to every reader, human or machine. (draft — not yet reviewed) - [Coding Convention](https://aipatternbook.com/coding-convention): A written, agreed rule about how the team writes code, captured as a living artifact that both humans and agents can read and follow. (draft — not yet reviewed) - [Aggregate](https://aipatternbook.com/aggregate): A cluster of entities and value objects treated as a single unit for data changes, with one root entity guarding the boundary. (draft — not yet reviewed) - [Bounded Context](https://aipatternbook.com/bounded-context): A line drawn around a part of the system where every term has exactly one meaning, keeping models focused and language honest. (draft — not yet reviewed) - [Business Capability](https://aipatternbook.com/business-capability): Names what a business does, independent of who does it or how, so strategy, software, and teams can align around stable anchors. (draft — not yet reviewed) ## Computation and Interaction - [Algorithm](https://aipatternbook.com/algorithm): A finite sequence of well-defined steps that takes input and produces a result, precise enough for a machine to follow without judgment. (draft — not yet reviewed) - [Algorithmic Complexity](https://aipatternbook.com/algorithmic-complexity): The vocabulary for how an algorithm's time and space cost grow as its input grows, naming the gap between fast and intractable. (draft — not yet reviewed) - [API](https://aipatternbook.com/api): The agreed-upon surface where one program talks to another, defining what you can ask for, in what format, and what you get back. (draft — not yet reviewed) - [Protocol](https://aipatternbook.com/protocol): The rules governing how a conversation over an API unfolds: who speaks first, which messages are valid at each step, and how errors are signaled. (draft — not yet reviewed) - [Determinism](https://aipatternbook.com/determinism): The property that the same inputs to the same code produce the same outputs every time, letting a team reason about what is repeatable. (draft — not yet reviewed) - [Side Effect](https://aipatternbook.com/side-effect): Any observable change a function makes beyond returning its result, distinguishing code that calculates from code that acts on the world. (draft — not yet reviewed) - [Concurrency](https://aipatternbook.com/concurrency): The property of a system whose activities are in progress at overlapping times, and the vocabulary for how those activities are structured. (draft — not yet reviewed) - [Event](https://aipatternbook.com/event): An immutable record that something happened at a point in time, by which one part of a system tells the rest what just occurred. (draft — not yet reviewed) ## Correctness, Testing, and Evolution - [Invariant](https://aipatternbook.com/invariant): A condition that must always hold regardless of what changes around it, expressing what your code can never be allowed to violate. (draft — not yet reviewed) - [Test](https://aipatternbook.com/test): An executable claim about what code should do, run automatically to confirm the behavior holds and to catch it when it stops. (draft — not yet reviewed) - [Test Oracle](https://aipatternbook.com/test-oracle): The mechanism that decides whether a test's output is correct, turning a program that merely runs code into one that verifies it did the right thing. (draft — not yet reviewed) - [LLM-as-Judge](https://aipatternbook.com/llm-as-judge): Use one model to score another's output against a written rubric, evaluating non-deterministic agent work at machine cost without losing most of the signal. (draft — not yet reviewed) - [Harness](https://aipatternbook.com/harness): The infrastructure that discovers tests, runs them, captures results, and reports pass or fail, making testing practical at scale. (draft — not yet reviewed) - [Fixture](https://aipatternbook.com/fixture): The known starting state a test runs against, giving each test a clean, predictable foundation so failures point at the code, not the environment. (draft — not yet reviewed) - [Test-Driven Development](https://aipatternbook.com/test-driven-development): Write the test before the code, and let failing tests drive every line of implementation. (draft — not yet reviewed) - [Red/Green TDD](https://aipatternbook.com/red-green-tdd): The mechanical loop that makes test-driven development concrete: write a failing test, make it pass, refactor, and repeat. (draft — not yet reviewed) - [Refactor](https://aipatternbook.com/refactor): Improve the internal structure of working code without changing its external behavior, made safe by tests. (draft — not yet reviewed) - [Regression](https://aipatternbook.com/regression): A behavior that used to work and no longer does, broken by an unrelated edit rather than an intentional change, distinct from other defects. (draft — not yet reviewed) - [Test Pyramid](https://aipatternbook.com/test-pyramid): A heuristic for allocating testing effort: many fast, cheap tests at the base, fewer slow, expensive tests at the top. (draft — not yet reviewed) - [Smoke Test](https://aipatternbook.com/smoke-test): A broad-but-shallow set of checks that confirm a build is not catastrophically broken before investing time in deeper testing. (draft — not yet reviewed) - [Exploratory Testing](https://aipatternbook.com/exploratory-testing): Learn the system, design a probe, run it, and let what you observe decide what to probe next, all in the same short session. (draft — not yet reviewed) - [Agentic Manual Testing](https://aipatternbook.com/agentic-manual-testing): Have an agent do the clicking, typing, and watching a human QA tester used to: start the server, try the flow, read the result, and report what broke. (draft — not yet reviewed) - [Consumer-Driven Contract Testing](https://aipatternbook.com/consumer-driven-contract-testing): Let each consumer declare the parts of an API it depends on, then verify the provider against every consumer before release so no real caller breaks. (draft — not yet reviewed) - [Observability](https://aipatternbook.com/observability): The degree to which a running system's internal state can be inferred from the signals it emits, naming whether the software is legible or opaque. (draft — not yet reviewed) - [Domain-Oriented Observability](https://aipatternbook.com/domain-oriented-observability): Treat business-meaningful events like cart-abandoned or payment-declined as first-class instrumentation, alongside low-level technical telemetry. (draft — not yet reviewed) - [Agent Trace](https://aipatternbook.com/agent-trace): The structured record of one agent run, captured as a tree of spans where each span is a model call, tool invocation, sub-agent dispatch, or retrieval. (draft — not yet reviewed) - [Failure Mode](https://aipatternbook.com/failure-mode): A specific, named way a system breaks or degrades, letting a team talk about one failure path instead of lumping everything into "it broke." (draft — not yet reviewed) - [Silent Failure](https://aipatternbook.com/silent-failure): A defect that produces no signal when it occurs, making the absence of an error message itself a kind of error rather than a sign of health. (draft — not yet reviewed) - [Fail Fast and Loud](https://aipatternbook.com/fail-fast-and-loud): Detect invalid state at the earliest possible point and surface it in a way that's impossible to ignore, so nothing builds on a broken foundation. (draft — not yet reviewed) - [Performance Envelope](https://aipatternbook.com/performance-envelope): The bounded region of load, latency, and resource use inside which a system behaves acceptably, naming what "fast enough" actually means. (draft — not yet reviewed) - [Logging](https://aipatternbook.com/logging): Record what your software does as it runs, so you can understand its behavior after the fact. (draft — not yet reviewed) - [Happy Path](https://aipatternbook.com/happy-path): The default scenario where everything works as expected, the baseline that makes every other kind of testing meaningful. (draft — not yet reviewed) - [Code Review](https://aipatternbook.com/code-review): Have someone other than the author examine code changes before they merge, catching defects, enforcing standards, and spreading knowledge. (draft — not yet reviewed) - [Printf Debugging](https://aipatternbook.com/printf-debugging): Insert temporary output statements to test a hypothesis about code behavior, then remove them once you've found the answer. (draft — not yet reviewed) - [Metric](https://aipatternbook.com/metric): A quantified signal that tells you whether your software, team, or process is improving, degrading, or standing still. (draft — not yet reviewed) - [Feedback Loop](https://aipatternbook.com/feedback-loop): Any arrangement where a process's output becomes its own input, letting the system self-correct, self-reinforce, or drift. (draft — not yet reviewed) - [Service Level Objective](https://aipatternbook.com/service-level-objective): Pick a reliability target you will defend, measure how often you meet it, and use the slack to decide when to ship and when to slow down. (draft — not yet reviewed) - [Technical Debt](https://aipatternbook.com/technical-debt): Shortcuts in code act like financial debt: they let you ship faster now and charge interest on every future change. (draft — not yet reviewed) - [Greenfield and Brownfield](https://aipatternbook.com/greenfield-and-brownfield): Greenfield builds from a clean slate; brownfield works around an existing system's contracts and invariants. Naming which one, out loud, steers the agent. (draft — not yet reviewed) - [Strangler Fig](https://aipatternbook.com/strangler-fig): Replace a legacy system incrementally by building new functionality alongside it and routing traffic piece by piece until the old system can be switched off. (draft — not yet reviewed) - [Parallel Change](https://aipatternbook.com/parallel-change): Change an interface by adding the new form first, migrating callers at their own pace, and removing the old form last, so consumers never see a break. (draft — not yet reviewed) - [Deprecation](https://aipatternbook.com/deprecation): Announce a feature's removal date, keep it working meanwhile, watch who still uses it, and remove it only once usage has gone to zero. (draft — not yet reviewed) - [Evolutionary Modernization](https://aipatternbook.com/evolutionary-modernization): Treat modernization as an ongoing practice of small, verified replacements rather than a bounded project with a single risky cutover. (draft — not yet reviewed) - [Regenerative Software](https://aipatternbook.com/regenerative-software): Design so components can be deleted and rebuilt from their specs and tests, treating code as a disposable output of a durable design. (draft — not yet reviewed) - [Sweep](https://aipatternbook.com/sweep): Apply one rule uniformly across many files in a single disciplined pass, moving the codebase to a new convention without drift or dangling exceptions. (draft — not yet reviewed) ## Security and Trust - [Threat Model](https://aipatternbook.com/threat-model): A structured picture of what you're protecting, who might attack it, and how, built before you decide what defenses to put where. (draft — not yet reviewed) - [Attack Surface](https://aipatternbook.com/attack-surface): The set of points where an untrusted actor can supply input, observe output, or trigger behavior, naming what a team is defending. (draft — not yet reviewed) - [Trust Boundary](https://aipatternbook.com/trust-boundary): The line in a system where one level of trust gives way to another, marking where defenses belong and where safe-looking data must be rechecked. (draft — not yet reviewed) - [Authentication](https://aipatternbook.com/authentication): Establishing who is making a request when it crosses a trust boundary, distinct from deciding what they're allowed to do. (draft — not yet reviewed) - [Authorization](https://aipatternbook.com/authorization): Deciding what an authenticated actor is allowed to do, distinct from establishing who they are. (draft — not yet reviewed) - [Vulnerability](https://aipatternbook.com/vulnerability): A specific weakness in code, configuration, design, or process that an attacker can exploit, framing a defect as exploitable rather than merely incorrect. (draft — not yet reviewed) - [Least Privilege](https://aipatternbook.com/least-privilege): Grant each actor only the permissions its current task requires, so a compromise turns the fewest excess permissions into weapons. (draft — not yet reviewed) - [Agentic Payments](https://aipatternbook.com/agentic-payments): Give an agent the narrowest, most observable, most reversible way to spend money on your behalf. (draft — not yet reviewed) - [Secret](https://aipatternbook.com/secret): Any information whose disclosure would let an unauthorized party do harm, keys, tokens, passwords, and how they're stored, transmitted, and scoped. (draft — not yet reviewed) - [Input Validation](https://aipatternbook.com/input-validation): Checking whether incoming data is acceptable before acting on it, one of the most basic and effective defenses in software security. (draft — not yet reviewed) - [Output Encoding](https://aipatternbook.com/output-encoding): Render data safely for its destination context, HTML, SQL, shell, URL, so special characters can't be reinterpreted as commands. (draft — not yet reviewed) - [Sandbox](https://aipatternbook.com/sandbox): A controlled environment that restricts what untrusted code can access and do, so a mistake or attack can't damage the rest of the system. (draft — not yet reviewed) - [Agent Gateway](https://aipatternbook.com/agent-gateway): A reverse proxy that brokers every tool call between agents and tools, so authentication, authorization, audit, and policy live in one place. (draft — not yet reviewed) - [Blast Radius](https://aipatternbook.com/blast-radius): The set of things that go bad when one thing goes bad, naming the scope of damage separately from its likelihood. (draft — not yet reviewed) - [Prompt Injection](https://aipatternbook.com/prompt-injection): The vulnerability class where untrusted content in an LLM's input is interpreted as instructions rather than data. (draft — not yet reviewed) - [Tool Poisoning](https://aipatternbook.com/tool-poisoning): Trusting a tool's self-description, which tells you what its author wants you to believe rather than what the tool will actually do. (draft — not yet reviewed) - [Agent Trap](https://aipatternbook.com/agent-trap): Adversarial content planted in a resource an agent will process, designed to hijack its behavior by exploiting its environment rather than its model. (draft — not yet reviewed) - [Adversarial Cloaking](https://aipatternbook.com/adversarial-cloaking): An attacker detects that a visitor is an AI agent and serves it different content than a human would see, so the agent reads a reality that doesn't exist. (draft — not yet reviewed) - [RAG Poisoning](https://aipatternbook.com/rag-poisoning): Corrupting the external knowledge bases agents retrieve from, so they treat fabricated information as verified fact across sessions and users. (draft — not yet reviewed) ## Human-Facing Software - [UX](https://aipatternbook.com/ux): The umbrella quality covering every moment a person spends interacting with your system, deciding whether anyone can actually use it well. (draft — not yet reviewed) - [Affordance](https://aipatternbook.com/affordance): The property of a design element that communicates its own purpose, so a button looks pressable and a field looks editable. (draft — not yet reviewed) - [User Feedback](https://aipatternbook.com/user-feedback): The signals software sends back to the person using it, so they know whether an action worked, is still processing, or went wrong. (draft — not yet reviewed) - [Accessibility](https://aipatternbook.com/accessibility): Designing software so people with disabilities can use it, by making affordances and feedback work across visual, auditory, and tactile modalities. (draft — not yet reviewed) - [Internationalization](https://aipatternbook.com/internationalization): Preparing software's architecture to work across languages, scripts, and regions, the groundwork that makes later localization possible. (draft — not yet reviewed) - [Localization](https://aipatternbook.com/localization): Adapting internationalized software to a specific language, region, or culture, from translation to date formats to right-to-left layout. (draft — not yet reviewed) ## Operations and Change Management - [Environment](https://aipatternbook.com/environment): A particular runtime context, hardware, dependencies, configuration, and data, where your application executes, distinct from every other. (draft — not yet reviewed) - [Configuration](https://aipatternbook.com/configuration): Data that changes how software behaves without changing its source: connection strings, keys, flags, timeouts, the same code tuned per environment. (draft — not yet reviewed) - [Version Control](https://aipatternbook.com/version-control): The system of record for source code, where every change is tracked, attributed, and reversible, the foundation under nearly every other practice. (draft — not yet reviewed) - [Git Checkpoint](https://aipatternbook.com/git-checkpoint): A deliberate commit, branch, or tag marking a known-good state before or after risky work, using version control as a safety net. (draft — not yet reviewed) - [Migration](https://aipatternbook.com/migration): Changing the shape of data, schemas, or behavior while preserving what already exists, one of the most delicate tasks in software evolution. (draft — not yet reviewed) - [Ship](https://aipatternbook.com/ship): Putting a real, working outcome into users' hands and giving up the ability to silently change the version they see. (draft — not yet reviewed) - [Deployment](https://aipatternbook.com/deployment): Moving a version of your software into a running environment where it does real work, applying the right configuration for that target. (draft — not yet reviewed) - [Continuous Integration](https://aipatternbook.com/continuous-integration): Merge everyone's work into a shared mainline frequently and validate each merge automatically with builds and tests, so integration never becomes painful. (draft — not yet reviewed) - [Continuous Delivery](https://aipatternbook.com/continuous-delivery): Keep software in a releasable state at all times through an automated pipeline, so shipping is a routine decision rather than an event. (draft — not yet reviewed) - [Continuous Deployment](https://aipatternbook.com/continuous-deployment): Remove the manual gate from continuous delivery so every change that passes the pipeline ships to production automatically. (draft — not yet reviewed) - [Rollback](https://aipatternbook.com/rollback): Returning a system to a previously known-good state after a deployment goes wrong, a deployment run in reverse. (draft — not yet reviewed) - [Feature Flag](https://aipatternbook.com/feature-flag): A conditional check that turns a feature on or off through configuration, decoupling deploying code from exposing it to users. (draft — not yet reviewed) - [Runbook](https://aipatternbook.com/runbook): A documented, step-by-step procedure for a recurring operational task or incident, so the on-call engineer knows exactly what to do at 3 a.m. (draft — not yet reviewed) - [Cascade Failure](https://aipatternbook.com/cascade-failure): When one component's failure triggers failures in others, creating a chain reaction that can bring down a whole system faster than anyone can respond. (draft — not yet reviewed) ## Socio-Technical Systems - [Conway's Law](https://aipatternbook.com/conways-law): A system's structure mirrors the communication structure of the organization that built it, revealing the org chart hiding inside the architecture. (draft — not yet reviewed) - [Team Cognitive Load](https://aipatternbook.com/team-cognitive-load): The total mental effort a team or agent must spend to understand, maintain, and change the systems it owns. (draft — not yet reviewed) - [Ownership](https://aipatternbook.com/ownership): The answer to who is responsible for a piece of code; when nobody can answer, the code decays. (draft — not yet reviewed) - [Bounded Agency](https://aipatternbook.com/bounded-agency): The authority an actor holds to act for an organization, deliberately constrained by rules and guardrails so that delegation stays governable. (draft — not yet reviewed) - [Stream-Aligned Team](https://aipatternbook.com/stream-aligned-team): A team organized around a single value stream, responsible for everything needed to deliver that stream from idea to production. (draft — not yet reviewed) - [Enabling Team](https://aipatternbook.com/enabling-team): A temporary, teaching-oriented team that helps stream-aligned teams acquire new capabilities without taking ownership of those capabilities away. (draft — not yet reviewed) - [Platform as a Product](https://aipatternbook.com/platform-as-a-product): Treat your internal developer platform with the discipline of a product for paying customers: know your users, measure adoption, make the easy path right. (draft — not yet reviewed) - [Thinnest Viable Platform](https://aipatternbook.com/thinnest-viable-platform): Build the smallest platform that lets stream-aligned teams deliver autonomously, then grow it only in response to real demand. (draft — not yet reviewed) - [Organizational Debt](https://aipatternbook.com/organizational-debt): The accumulated cost of shortcuts in how teams are structured, decisions made, and responsibilities assigned, compounding silently until movement stalls. (draft — not yet reviewed) - [Inverse Conway Maneuver](https://aipatternbook.com/inverse-conway-maneuver): Reshape your teams to produce the architecture you actually want, instead of accepting that the software will mirror your existing org chart. (draft — not yet reviewed) ## Design Heuristics and Smells - [KISS](https://aipatternbook.com/kiss): Keep it simple: prefer the least complex design that solves the problem, since complexity added without clarity is a cost you keep paying. (draft — not yet reviewed) - [YAGNI](https://aipatternbook.com/yagni): You aren't gonna need it: don't build features, abstractions, or infrastructure for needs that haven't materialized. (draft — not yet reviewed) - [Local Reasoning](https://aipatternbook.com/local-reasoning): Structuring code so you can understand a piece of it without holding the whole system in your head. (draft — not yet reviewed) - [Make Illegal States Unrepresentable](https://aipatternbook.com/make-illegal-states-unrepresentable): Arrange types and data structures so invalid combinations of state literally cannot be constructed, moving whole bug classes from runtime to compile time. (draft — not yet reviewed) - [Smell (Code Smell)](https://aipatternbook.com/code-smell): A surface feature of working code that hints at a deeper design problem, giving reviewers fast vocabulary for the intuitions they already have. (draft — not yet reviewed) - [Smell (AI Smell)](https://aipatternbook.com/ai-smell): A surface pattern in model-generated output that suggests it was produced for plausibility rather than understanding, before you can prove it wrong. (draft — not yet reviewed) - [Cargo Cult Programming](https://aipatternbook.com/cargo-cult-programming): Copying the visible shape of working software without understanding the invariant that made the original work. (draft — not yet reviewed) - [Architecture Astronaut](https://aipatternbook.com/architecture-astronaut): Designing at an altitude so high that the abstractions stop touching any real problem. (draft — not yet reviewed) - [Speculative Generality](https://aipatternbook.com/speculative-generality): Adding hooks, abstractions, parameters, and extension points for future needs that have not become real requirements. (draft — not yet reviewed) - [Jagged Frontier](https://aipatternbook.com/jagged-frontier): AI capability shaped like a coastline, not a horizon: equally hard-looking tasks fall on opposite sides of an invisible line between nailing it and failing confidently. (draft — not yet reviewed) - [Load-Bearing](https://aipatternbook.com/load-bearing): Code, comments, tests, or instructions whose removal would break something important, usually in a way that isn't obvious from looking at it. (draft — not yet reviewed) - [Pinning](https://aipatternbook.com/pinning): Explicitly fixing a choice, model, prompt, dependency version, so downstream work can rely on it not changing without a deliberate, traceable update. (draft — not yet reviewed) - [Footgun](https://aipatternbook.com/footgun): A feature, default, or construct that is easy to use wrong and hard to use right, making self-inflicted damage the path of least resistance. (draft — not yet reviewed) - [DWIM](https://aipatternbook.com/dwim): A design stance that treats user input as evidence of probable intent, inferring and acting on the likely meaning rather than the literal one. (draft — not yet reviewed) - [Best Current Practice](https://aipatternbook.com/best-current-practice): A recommendation reflecting what the community knows today, with the built-in expectation that it will change as understanding improves. (draft — not yet reviewed) - [Premature Optimization](https://aipatternbook.com/premature-optimization): Spending effort making code faster before you know whether it's correct, whether it's the bottleneck, or whether it will survive the next change. (draft — not yet reviewed) - [Vibe Coding](https://aipatternbook.com/vibe-coding): Generating code through natural-language prompts without reading, understanding, or verifying the output, then shipping it anyway. (draft — not yet reviewed) ## Agentic Software Construction - [Model](https://aipatternbook.com/model): The large language model underneath every agentic coding workflow, whose properties shape what you can ask it to do. (draft — not yet reviewed) - [Prompt](https://aipatternbook.com/prompt): The instruction set given to a model to steer its behavior, from a single typed sentence to a structured system message assembled by a harness. (draft — not yet reviewed) - [Context Window](https://aipatternbook.com/context-window): The bounded working memory inside which a model sees everything it knows about the current task. (draft — not yet reviewed) - [Context Rot](https://aipatternbook.com/context-rot): An LLM's output quality degrades as its input grows longer, even when the context window is nowhere near full. (draft — not yet reviewed) - [Context Engineering](https://aipatternbook.com/context-engineering): The discipline of deciding what information fills an agent's finite context window, and when, so the model sees what it needs and little else. (draft — not yet reviewed) - [Progressive Disclosure](https://aipatternbook.com/progressive-disclosure): Load context into the agent only when it's needed, so the finite window holds what the current step requires rather than everything up front. (draft — not yet reviewed) - [Agent](https://aipatternbook.com/agent): A model running in a loop with tools, able to accept a goal and pursue it across many steps without typing each instruction yourself. (draft — not yet reviewed) - [Harness (Agentic)](https://aipatternbook.com/harness-agentic): The program that wraps a model in a loop, manages its tools, and turns raw inference into an agent that can act on a codebase. (draft — not yet reviewed) - [Harness Engineering](https://aipatternbook.com/harness-engineering): Designing the configuration surfaces around a coding agent so that a fixed model produces reliable outcomes in a specific codebase. (draft — not yet reviewed) - [REPL](https://aipatternbook.com/repl): Wrap an agent in a persistent read-eval-print loop so a human can direct it conversationally, one turn at a time, with session state preserved. (draft — not yet reviewed) - [Deep Agents](https://aipatternbook.com/deep-agents): The composite recipe behind production coding agents: explicit planning, sub-agent delegation, persistent memory, and an extreme context-engineering layer. (draft — not yet reviewed) - [Tool](https://aipatternbook.com/tool): A callable capability exposed to an agent, turning a text generator into something that can read files, run commands, and act on the world. (draft — not yet reviewed) - [Agent-Computer Interface (ACI)](https://aipatternbook.com/agent-computer-interface): The tools, affordances, and interaction formats through which an agent acts on a computer, designed for the model's cognition rather than a human's. (draft — not yet reviewed) - [MCP (Model Context Protocol)](https://aipatternbook.com/mcp): An open protocol that standardizes how an agent discovers, invokes, and receives results from external tools and data sources, regardless of who built them. (draft — not yet reviewed) - [Structured Outputs](https://aipatternbook.com/structured-outputs): Constrain a model's response to a known schema so the next program in the pipeline can parse it without guessing. (draft — not yet reviewed) - [Retrieval](https://aipatternbook.com/retrieval): Let an agent pull relevant information from an external corpus at query time, so it can work with knowledge that isn't baked into its training weights. (draft — not yet reviewed) - [ReAct](https://aipatternbook.com/react): Interleave a thought, an action, and an observation on every step so the agent plans against what it actually sees, not what it first assumed. (draft — not yet reviewed) - [Code Mode](https://aipatternbook.com/code-mode): Give an agent a small API and let it write code that calls tools inside a sandbox, instead of emitting one JSON tool call at a time. (draft — not yet reviewed) - [Plan Mode](https://aipatternbook.com/plan-mode): Have the agent explore the codebase and propose a plan for human review before it makes changes: measure twice, cut once. (draft — not yet reviewed) - [Question Generation](https://aipatternbook.com/question-generation): Make the agent interview you before it writes a single line of code, surfacing the requirements you would otherwise discover only after the work is wrong. (draft — not yet reviewed) - [Research, Plan, Implement](https://aipatternbook.com/research-plan-implement): Separate understanding from decision-making from execution, so each phase produces a reviewable artifact before the next begins. (draft — not yet reviewed) - [Verification Loop](https://aipatternbook.com/verification-loop): The agent's core quality mechanism: run the work, check the result against an oracle, and iterate until it passes. (draft — not yet reviewed) - [Interactive Explanations](https://aipatternbook.com/interactive-explanations): When an agent writes code you don't yet understand, have it build a small interactive visualization so you form intuition a static description can't give. (draft — not yet reviewed) - [Reflexion](https://aipatternbook.com/reflexion): Force the agent to articulate why its last attempt failed, store that reflection as memory, and feed it back as context for the next try. (draft — not yet reviewed) - [Plan-and-Execute](https://aipatternbook.com/plan-and-execute): Split the agent into a planner, an executor, and a re-planner so the expensive reasoning model isn't re-deriving the same plan on every tool call. (draft — not yet reviewed) - [Agentic Context Engineering](https://aipatternbook.com/agentic-context-engineering): Treat the agent's working context as an evolving playbook of tagged bullets, updated incrementally by specialized roles instead of monolithic rewrites. (draft — not yet reviewed) - [Subagent](https://aipatternbook.com/subagent): An agent spawned with a delegated, focused scope, so a parent agent can hand off a self-contained piece of work and reclaim its own context. (draft — not yet reviewed) - [Skill](https://aipatternbook.com/skill): A packaged, reusable capability an agent can invoke, bundling the instructions and tools a recurring workflow needs into one named unit. (draft — not yet reviewed) - [Hook](https://aipatternbook.com/hook): Attach automation to lifecycle points in an agentic workflow so checks, formatting, and bookkeeping happen without anyone remembering to do them. (draft — not yet reviewed) - [Instruction File](https://aipatternbook.com/instruction-file): A durable, project-scoped document that gives an agent persistent knowledge of your conventions, architecture, and constraints across every session. (draft — not yet reviewed) - [Memory](https://aipatternbook.com/memory): How an agent persists knowledge beyond a single session's context window, so it can carry forward what it learned without re-deriving it each time. (draft — not yet reviewed) - [Compound Engineering](https://aipatternbook.com/compound-engineering): Convert every shipped unit of work into a durable, agent-readable lesson before it closes, so the next feature is genuinely cheaper than the last. (draft — not yet reviewed) - [Agentic Engineering](https://aipatternbook.com/agentic-engineering): The discipline of orchestrating coding agents to ship production software, where the human writes the spec and reviews while agents write almost all the code. (draft — not yet reviewed) - [Thread-per-Task](https://aipatternbook.com/thread-per-task): Give each coherent unit of work its own conversation thread instead of running one sprawling session across many features and fixes. (draft — not yet reviewed) - [Worktree Isolation](https://aipatternbook.com/worktree-isolation): Give each agent its own checkout of the codebase so simultaneous work by agents and humans cannot collide. (draft — not yet reviewed) - [Compaction](https://aipatternbook.com/compaction): When a conversation outgrows the model's memory, distilling what matters so the work can continue without losing the thread. (draft — not yet reviewed) - [Context Offloading](https://aipatternbook.com/context-offloading): Route large tool results to the filesystem and pass the agent a summary plus a reference, keeping active context small while the full payload stays retrievable. (draft — not yet reviewed) - [Prompt Caching](https://aipatternbook.com/prompt-caching): Pin the unchanging part of your prompt at the front so the provider can reuse its computed state and charge a fraction of the cost on every reuse. (draft — not yet reviewed) - [Progress Log](https://aipatternbook.com/progress-log): A durable record of what an agent attempted, succeeded at, and failed at, persisted in a file that survives across sessions and context resets. (draft — not yet reviewed) - [Checkpoint](https://aipatternbook.com/checkpoint): A gate where an agent pauses, verifies that conditions hold, and proceeds only if they pass. (draft — not yet reviewed) - [Externalized State](https://aipatternbook.com/externalized-state): Store an agent's plan, progress, and results in inspectable files so workflows survive interruptions and humans can see what the agent intends to do. (draft — not yet reviewed) - [Task Horizon](https://aipatternbook.com/task-horizon): The length of task an agent can complete reliably on its own, measured against the same work done by a human expert. (draft — not yet reviewed) - [Parallelization](https://aipatternbook.com/parallelization): Run independent pieces of a task across multiple agents at once, using isolation and decomposition to keep their work from colliding. (draft — not yet reviewed) - [Orchestrator-Workers](https://aipatternbook.com/orchestrator-workers): A central agent inspects a goal, invents the subtasks it implies, dispatches workers to handle each, and synthesizes their results. (draft — not yet reviewed) - [Back-Pressure (Agent)](https://aipatternbook.com/back-pressure): The pacing mechanisms that keep an agent from overwhelming itself, its tools, or the humans and systems around it. (draft — not yet reviewed) - [Ralph Wiggum Loop](https://aipatternbook.com/ralph-wiggum-loop): A simple outer loop restarts an agent with fresh context after each unit of work, letting a bash script do what orchestration frameworks promise. (draft — not yet reviewed) - [Agent Teams](https://aipatternbook.com/agent-teams): Let multiple agents claim tasks from a shared list and merge their own work, so the human stops being the coordination bottleneck. (draft — not yet reviewed) - [Generator-Evaluator](https://aipatternbook.com/generator-evaluator): Split code creation and code critique into separate agents so that neither role can blind the other. (draft — not yet reviewed) - [Model Routing](https://aipatternbook.com/model-routing): Match the model to the task so you spend your budget where it matters and your time where it counts. (draft — not yet reviewed) - [A2A (Agent-to-Agent Protocol)](https://aipatternbook.com/a2a): A standard protocol for agents to discover each other's capabilities, exchange messages, and collaborate across vendor and framework boundaries. (draft — not yet reviewed) - [Handoff](https://aipatternbook.com/handoff): When work moves between agents or sessions, curating the context the receiver needs so nothing important is lost and nothing irrelevant comes along. (draft — not yet reviewed) ## Agent Governance and Feedback - [Approval Policy](https://aipatternbook.com/approval-policy): Defines when an agent may act on its own and when it must pause for human confirmation: the contract between the human's trust and the agent's autonomy. (draft — not yet reviewed) - [Permission Classifier](https://aipatternbook.com/permission-classifier): A small, fast model judges each proposed agent action and decides whether it can run on its own, needs a human, or should be blocked outright. (draft — not yet reviewed) - [Runtime Governance](https://aipatternbook.com/runtime-governance): Intercept every tool call, model call, and state change on the action path at machine speed and rule it allow, throttle, sandbox, escalate, or block. (draft — not yet reviewed) - [Eval](https://aipatternbook.com/eval): A repeatable suite that measures how well an agentic workflow performs, applying the discipline of testing to the agent itself rather than its output. (draft — not yet reviewed) - [Human in the Loop](https://aipatternbook.com/human-in-the-loop): Keep a person inside the control structure of an agentic workflow, positioned at the moments where human judgment matters most. (draft — not yet reviewed) - [Feedforward](https://aipatternbook.com/feedforward): Any control you place before the agent acts, steering it toward correct output on the first attempt. (draft — not yet reviewed) - [Feedback Sensor](https://aipatternbook.com/feedback-sensor): Any check that runs after an agent acts, telling it what went wrong so it can correct course. (draft — not yet reviewed) - [Steering Loop](https://aipatternbook.com/steering-loop): The closed cycle where an agent acts, receives feedback, and adjusts, turning raw model output into reliable results through iteration. (draft — not yet reviewed) - [Harnessability](https://aipatternbook.com/harnessability): The degree to which a codebase's structure makes it tractable for agents to work in safely and effectively. (draft — not yet reviewed) - [Bounded Autonomy](https://aipatternbook.com/bounded-autonomy): Calibrate an agent's freedom to the reversibility and consequence of each action, so low-risk work flows while high-stakes decisions wait for a human. (draft — not yet reviewed) - [Dark Factory](https://aipatternbook.com/dark-factory): An operating model where coding agents write, test, and ship production code with no human reviewing the code; humans set only goals and constraints. (draft — not yet reviewed) - [Agent Registry](https://aipatternbook.com/agent-registry): A governed, queryable catalog of every agent in the organization, recording what each does, who owns it, what it touches, and when it was last reviewed. (draft — not yet reviewed) - [Approval Fatigue](https://aipatternbook.com/approval-fatigue): When approval requests arrive faster than a human can read them, oversight collapses into rubber-stamping. (draft — not yet reviewed) - [Shadow Agent](https://aipatternbook.com/shadow-agent): An agent operating inside your organization without anyone in governance knowing it exists, holding live credentials and acting under no one's authority. (draft — not yet reviewed) - [Agent Sprawl](https://aipatternbook.com/agent-sprawl): Agents proliferate faster than governance can keep up, until nobody can say how many are running, what they touch, or who owns them. (draft — not yet reviewed) - [Tool Sprawl](https://aipatternbook.com/tool-sprawl): A single agent's tool catalog grows past the model's ability to choose among its members, and accuracy collapses as the list keeps expanding. (draft — not yet reviewed) - [Garbage Collection](https://aipatternbook.com/garbage-collection): Recurring, agent-driven sweeps that find where a codebase has drifted from its standards and fix the drift before it compounds. (draft — not yet reviewed) - [Shift-Left Feedback](https://aipatternbook.com/shift-left-feedback): Move quality checks as close to the point of creation as possible, so agents catch mistakes while they can still fix them cheaply. (draft — not yet reviewed) - [Feedback Flywheel](https://aipatternbook.com/feedback-flywheel): Harvest corrections from AI-assisted work, distill them into rules, and feed those rules into instruction files so each session's frustrations become the next session's defaults. (draft — not yet reviewed) - [Delegation Chain](https://aipatternbook.com/delegation-chain): The path authority follows from a human through one or more agents, where each link can amplify, misdirect, or quietly exceed the original intent. (draft — not yet reviewed) - [Architecture Fitness Function](https://aipatternbook.com/architecture-fitness-function): An automated check that verifies your system still honors a specific architectural decision, catching structural drift before it compounds. (draft — not yet reviewed) - [AgentOps](https://aipatternbook.com/agentops): Operating, monitoring, and governing AI agents in production, applying DevOps discipline to systems that reason, choose tools, and act for users. (draft — not yet reviewed) ## Optional - [Colophon](https://aipatternbook.com/colophon): Publication credits and a note on how this living encyclopedia is researched, written, edited, and deployed by the Bartley engine under human editorial standards. - [Meta Report](https://aipatternbook.com/meta-report): The Bartley engine's lab notebook, where after each self-evaluation cycle it reports what it measured, what it learned, and what it changed about its own process.