# The lex records whose kind is anti-pattern

This index as JSON: https://banes-lab.com/json/api/facets/lex/kind/anti-pattern

## Entries

- [Ad-Hoc Design](https://banes-lab.com/records/lex/ad-hoc-design.md): Designing by improvisation with no deliberate structure or review, so the architecture accretes inconsistently.
- [Ad-Hoc Pattern Mixing](https://banes-lab.com/records/lex/ad-hoc-pattern-mixing.md): Combining unrelated design patterns arbitrarily with no coherent rationale, producing an inconsistent structure.
- [Architecture Drift](https://banes-lab.com/records/lex/architecture-drift.md): Gradual divergence of an implementation from its intended architecture as unreviewed changes accumulate.
- [Assumption-Based Judgment](https://banes-lab.com/records/lex/assumption-based-judgment.md): Judging an architecture from untested assumptions instead of measured evidence, yielding unreliable conclusions.
- [Blind Change](https://banes-lab.com/records/lex/blind-change.md): Changing a system without analyzing what the change affects, so unintended consequences go unseen.
- [Cargo-Cult Pattern Use](https://banes-lab.com/records/lex/cargo-cult-pattern-use.md): Applying a design pattern by imitation without understanding the problem it solves, adding structure that fits nothing.
- [Direct-to-main Unreviewed Change](https://banes-lab.com/records/lex/direct-to-main-unreviewed-change.md): Pushing changes straight to the main branch with no review, so unvetted code lands directly in production.
- [Manual Architecture Review Only](https://banes-lab.com/records/lex/manual-architecture-review-only.md): Relying solely on human review to police architecture, with no automated checks, so violations slip through.
- [Over-Architecture](https://banes-lab.com/records/lex/over-architecture.md): Building more architectural structure than the problem needs, adding cost and rigidity with no payoff.
- [Tribal Knowledge](https://banes-lab.com/records/lex/tribal-knowledge.md): Critical architectural knowledge held only in the developers' heads and never recorded, lost when they leave.
- [Uncoordinated Divergence](https://banes-lab.com/records/lex/uncoordinated-divergence.md): Teams independently diverging from a shared reference architecture, fragmenting the system into incompatible variants.
- [Unbounded Variation](https://banes-lab.com/records/lex/unbounded-variation.md): Allowing unlimited variation in how the same problem is solved, so the system sprawls into inconsistent one-offs.
- [Unreviewed Structural Change](https://banes-lab.com/records/lex/unreviewed-structural-change.md): Merging changes to architectural structure without review, letting unvetted design decisions into the system.
- [Undefined Target](https://banes-lab.com/records/lex/undefined-target.md): Attempting to close a gap toward a goal that was never clearly defined, so progress cannot be judged.
- [Direct Callback Coupling](https://banes-lab.com/records/lex/direct-callback-coupling.md): Wiring a source to notify specific recipients by direct call, coupling it to each one.
- [Direct Method Invocation](https://banes-lab.com/records/lex/direct-method-invocation.md): Invoking an operation by direct method call, so it cannot be queued, logged, or undone.
- [Duplicated Workflow](https://banes-lab.com/records/lex/duplicated-workflow.md): Repeating the same overall algorithm in many places, each copy re-implementing the shared steps.
- [Exposed Internal Representation](https://banes-lab.com/records/lex/exposed-internal-representation.md): Forcing clients to traverse a collection through its internal structure, coupling them to that structure.
- [External State Reach-In](https://banes-lab.com/records/lex/external-state-reach-in.md): Reading or writing an object's internal state from outside to snapshot it, breaking its encapsulation.
- [Flat State Explosion](https://banes-lab.com/records/lex/flat-state-explosion.md): Enumerating every combination of conditions as a separate flat state, so the state count explodes.
- [Large Conditional Logic](https://banes-lab.com/records/lex/large-conditional-logic.md): Selecting behavior with a large branching conditional instead of pluggable strategy objects.
- [Mesh Dependencies](https://banes-lab.com/records/lex/mesh-dependencies.md): Letting every object refer directly to every other, forming a dense mesh of point-to-point dependencies.
- [Monolithic Handler](https://banes-lab.com/records/lex/monolithic-handler.md): Handling every case in one large handler instead of a chain of focused, single-purpose handlers.
- [Type-Switch Dispatch](https://banes-lab.com/records/lex/type-switch-dispatch.md): Dispatching behavior with a switch on an object's type instead of double dispatch through a visitor.
- [Unordered Side Effects](https://banes-lab.com/records/lex/unordered-side-effects.md): Applying side effects in an order that ignores their causal dependencies, producing incorrect outcomes.
- [Arbitrary Reordering](https://banes-lab.com/records/lex/arbitrary-reordering.md): Reordering causally related operations freely, so effects can appear before their causes.
- [Unordered Parallel Consumption](https://banes-lab.com/records/lex/unordered-parallel-consumption.md): Consuming an ordered event stream in parallel without preserving order, so state is updated out of sequence.
- [Hidden Dependency](https://banes-lab.com/records/lex/hidden-dependency.md): An unstated dependency between operations, so order-sensitive code breaks when the hidden ordering is not preserved.
- [Single Global Clock Assumption](https://banes-lab.com/records/lex/single-global-clock-assumption.md): Assuming a single global clock orders all events, which fails across distributed nodes with independent clocks.
- [Wall-Clock Ordering Assumption](https://banes-lab.com/records/lex/wall-clock-ordering-assumption.md): Ordering distributed events by wall-clock timestamps, which clock skew makes unreliable.
- [Physical-Clock-Only Ordering](https://banes-lab.com/records/lex/physical-clock-only-ordering.md): Ordering events by physical clocks alone, which clock skew renders inconsistent across nodes.
- [Per-Node Independent Ordering](https://banes-lab.com/records/lex/per-node-independent-ordering.md): Letting each node decide message order independently, so replicas diverge on sequence.
- [Assumed Total Consistency And Availability](https://banes-lab.com/records/lex/assumed-total-consistency-and-availability.md): Assuming a distributed system can be fully consistent and available at once, ignoring partitions that force a choice.
- [Consistency Assumed Free When Healthy](https://banes-lab.com/records/lex/consistency-assumed-free-when-healthy.md): Assuming consistency carries no cost while the network is healthy, ignoring the latency it still imposes.
- [Central Database Bottleneck](https://banes-lab.com/records/lex/central-database-bottleneck.md): Funneling all state through one shared database that becomes the system's scaling bottleneck.
- [Framework-Centric Core](https://banes-lab.com/records/lex/framework-centric-core.md): Building the core around a specific framework, so the framework's concerns permeate the domain.
- [Infrastructure-Centric Design](https://banes-lab.com/records/lex/infrastructure-centric-design.md): Designing the core around infrastructure details, so business logic depends on technical specifics.
- [Layer Leakage](https://banes-lab.com/records/lex/layer-leakage.md): Letting an inner layer depend on an outer one, violating the direction of the dependency rule.
- [Layer Skipping](https://banes-lab.com/records/lex/layer-skipping.md): Bypassing intermediate layers to call a distant layer directly, undermining the layering.
- [Monolithic Transform Function](https://banes-lab.com/records/lex/monolithic-transform-function.md): Doing all processing in one large transform instead of a series of composable filter stages.
- [Package by Technical Layer Only](https://banes-lab.com/records/lex/package-by-technical-layer-only.md): Organizing code by technical layer alone, scattering each feature across many packages.
- [Shared Monolithic Application](https://banes-lab.com/records/lex/shared-monolithic-application.md): Building one large shared application instead of composing independently-governed services.
- [Unbounded Big Ball of Mud](https://banes-lab.com/records/lex/unbounded-big-ball-of-mud.md): Letting a system grow without structure into a tangled mass with no clear boundaries.
- [Ad-Hoc Endpoints](https://banes-lab.com/records/lex/ad-hoc-endpoints.md): Exposing inconsistent, one-off endpoints instead of a uniform interface, forcing clients to special-case each.
- [Ad-Hoc Payloads](https://banes-lab.com/records/lex/ad-hoc-payloads.md): Sending payloads with no agreed schema, so consumers must guess at structure and break on change.
- [Breaking API Change](https://banes-lab.com/records/lex/breaking-api-change.md): Changing an API in a way that violates its published contract, breaking existing clients.
- [Breaking Change](https://banes-lab.com/records/lex/breaking-change.md): A change that violates a component's contract, forcing consumers to update to keep working.
- [Breaking Changes](https://banes-lab.com/records/lex/breaking-changes.md): Changes that break existing consumers by altering behavior or shape they depend on.
- [External State Mutation](https://banes-lab.com/records/lex/external-state-mutation.md): Mutating state outside an object's own boundary, breaking the invariants it is supposed to guarantee.
- [Hidden Service Coupling](https://banes-lab.com/records/lex/hidden-service-coupling.md): An undeclared dependency between services that surfaces only at runtime, undermining independent evolution.
- [Implementation-First Integration](https://banes-lab.com/records/lex/implementation-first-integration.md): Integrating against a concrete implementation before agreeing a contract, coupling consumers to internals.
- [Implicit Assumptions](https://banes-lab.com/records/lex/implicit-assumptions.md): Relying on unstated preconditions a caller must satisfy, which break silently when they are violated.
- [Implicit Behavior](https://banes-lab.com/records/lex/implicit-behavior.md): Behavior a component performs that is not stated in its contract, surprising callers who come to depend on it.
- [Implicit Payloads](https://banes-lab.com/records/lex/implicit-payloads.md): Passing data whose shape and meaning are never declared, so consumers infer them and break on change.
- [Proprietary Coupling](https://banes-lab.com/records/lex/proprietary-coupling.md): Binding to a vendor's proprietary interface, forfeiting interoperability and portability.
- [Proprietary Drift](https://banes-lab.com/records/lex/proprietary-drift.md): Extending a standard protocol with proprietary features until it no longer interoperates with others.
- [Silent Breaking Changes](https://banes-lab.com/records/lex/silent-breaking-changes.md): Shipping a breaking change with no version bump or notice, so consumers fail without warning.
- [Strict Fragile Parsers](https://banes-lab.com/records/lex/strict-fragile-parsers.md): Parsers that reject any input deviating from an exact expectation, breaking on benign additions.
- [Undefined Results](https://banes-lab.com/records/lex/undefined-results.md): Returning results a contract never specifies for a given input, leaving callers with undefined behavior.
- [Central Orchestrator Bottleneck](https://banes-lab.com/records/lex/central-orchestrator-bottleneck.md): Routing every interaction through one central orchestrator that becomes a bottleneck and single point of failure.
- [Centralized Control](https://banes-lab.com/records/lex/centralized-control.md): Concentrating decision-making authority in one place so nodes cannot act independently.
- [Fully Decentralized Control](https://banes-lab.com/records/lex/fully-decentralized-control.md): Leaving control fully decentralized with no central plane, so global runtime policy cannot be coordinated.
- [Independent Node Decisions](https://banes-lab.com/records/lex/independent-node-decisions.md): Letting each node decide independently with no agreement, so they diverge on shared state.
- [Local-Only Logs](https://banes-lab.com/records/lex/local-only-logs.md): Leaving logs scattered on each host with no aggregation, so cross-service analysis is impossible.
- [Pure Choreography](https://banes-lab.com/records/lex/pure-choreography.md): Coordinating a multi-step workflow purely through choreography when central orchestration is needed, scattering its logic.
- [Scattered Auth Implementations](https://banes-lab.com/records/lex/scattered-auth-implementations.md): Reimplementing authentication separately in each service instead of centralizing it.
- [Scattered Configuration](https://banes-lab.com/records/lex/scattered-configuration.md): Spreading configuration across many services with no single source, so values drift out of sync.
- [Split-Brain Coordination](https://banes-lab.com/records/lex/split-brain-coordination.md): Two nodes both believing they are leader and acting independently, corrupting shared state.
- [Anemic Encapsulation](https://banes-lab.com/records/lex/anemic-encapsulation.md): Wrapping data in a class that exposes it through trivial getters and setters, leaving its invariants unprotected.
- [Blob Class](https://banes-lab.com/records/lex/blob-class.md): A single class that absorbs many unrelated responsibilities, growing large and hard to change safely.
- [Centralized Runtime Control](https://banes-lab.com/records/lex/centralized-runtime-control.md): Concentrating runtime control in one place so otherwise-independent modules cannot act without it.
- [Context-Specific Coupling](https://banes-lab.com/records/lex/context-specific-coupling.md): Baking one caller's specific assumptions into a component, preventing its reuse elsewhere.
- [Copy-Paste Programming](https://banes-lab.com/records/lex/copy-paste-programming.md): Duplicating code by copying and pasting instead of extracting a shared abstraction.
- [Cross-Cutting Leakage](https://banes-lab.com/records/lex/cross-cutting-leakage.md): Letting a concern such as logging or security bleed into unrelated modules throughout the code.
- [Deep Inheritance Hierarchy](https://banes-lab.com/records/lex/deep-inheritance-hierarchy.md): Stacking many layers of subclassing, so behavior is scattered and fragile to change.
- [Exposed Internals](https://banes-lab.com/records/lex/exposed-internals.md): Making a module's internal fields and workings public, so callers depend on details that should be hidden.
- [Implementation-Specific Contracts](https://banes-lab.com/records/lex/implementation-specific-contracts.md): Defining an interface around one implementation's quirks, so no alternative can satisfy it.
- [Leaky Abstraction](https://banes-lab.com/records/lex/leaky-abstraction.md): An abstraction that forces callers to understand its underlying implementation to use it correctly.
- [Mixed Layers](https://banes-lab.com/records/lex/mixed-layers.md): Interleaving different architectural layers' logic in one place instead of keeping each concern separate.
- [Monolithic Procedures](https://banes-lab.com/records/lex/monolithic-procedures.md): Writing large all-in-one procedures that cannot be recombined from smaller, independent parts.
- [Shared Runtime Dependency](https://banes-lab.com/records/lex/shared-runtime-dependency.md): Coupling supposedly-independent modules through a shared runtime component they all depend on.
- [Tight Coupling](https://banes-lab.com/records/lex/tight-coupling.md): Binding components so closely that a change in one forces changes in the others.
- [Race Conditions](https://banes-lab.com/records/lex/race-conditions.md): A defect where the outcome depends on the uncontrolled interleaving of concurrent operations.
- [Single Point of Failure](https://banes-lab.com/records/lex/single-point-of-failure.md): A component whose failure alone halts the entire system because it has no redundancy.
- [Silent Failure](https://banes-lab.com/records/lex/silent-failure.md): A failure that occurs without surfacing any error, log, or signal, leaving it undetected.
- [Ambiguous Naming](https://banes-lab.com/records/lex/ambiguous-naming.md): Identifiers whose meaning is unclear or open to multiple interpretations, obscuring intent.
- [Boolean Flag Soup](https://banes-lab.com/records/lex/boolean-flag-soup.md): Representing state through many interdependent boolean flags, producing tangled and invalid combinations.
- [Cyclic Dependencies](https://banes-lab.com/records/lex/cyclic-dependencies.md): Dependencies that form a cycle among components, preventing independent build, test, or reasoning.
- [Hidden Dependencies](https://banes-lab.com/records/lex/hidden-dependencies.md): Dependencies a component relies on but does not declare in its interface, surfacing only at runtime.
- [Hidden Side Effects](https://banes-lab.com/records/lex/hidden-side-effects.md): State changes a function performs that are not evident from its name or signature, surprising callers.
- [Model Drift](https://banes-lab.com/records/lex/model-drift.md): The gradual loss of a model's fidelity to the reality it represents, as data or conditions change over time.
- [Assumption-Driven Delivery](https://banes-lab.com/records/lex/assumption-driven-delivery.md): Shipping on untested assumptions about behavior instead of validating that requirements are met.
- [Environment-Sensitive Behavior](https://banes-lab.com/records/lex/environment-sensitive-behavior.md): Behavior that changes with the host environment, so the same run yields different results elsewhere.
- [Example-Only Testing](https://banes-lab.com/records/lex/example-only-testing.md): Testing only a few hand-picked examples instead of properties that must hold across all inputs.
- [Floating Dependencies](https://banes-lab.com/records/lex/floating-dependencies.md): Depending on unpinned, floating dependency versions, so builds are not reproducible.
- [Hidden Behavior](https://banes-lab.com/records/lex/hidden-behavior.md): Behavior triggered by hidden state or side effects, so outcomes surprise callers.
- [Hidden IO](https://banes-lab.com/records/lex/hidden-io.md): Performing input/output inside a supposedly pure function, hiding side effects from callers.
- [Hidden Time/Randomness/Global State](https://banes-lab.com/records/lex/hidden-time-randomness-global-state.md): Reading the clock, randomness, or global state inside a computation, making its output nondeterministic.
- [Implementation-Only Testing](https://banes-lab.com/records/lex/implementation-only-testing.md): Testing only against the current implementation's behavior rather than the specified contract.
- [Informal Validation Only](https://banes-lab.com/records/lex/informal-validation-only.md): Relying only on informal checks and testing where a formal proof of correctness is warranted.
- [Side Effects](https://banes-lab.com/records/lex/side-effects.md): Producing observable side effects in an expression, so it cannot be replaced by its value.
- [Unchecked Dynamic Code](https://banes-lab.com/records/lex/unchecked-dynamic-code.md): Running dynamically generated or evaluated code that static analysis cannot inspect for defects.
- [Undefined Behavior](https://banes-lab.com/records/lex/undefined-behavior.md): Relying on operations whose result is unspecified, so outcomes vary unpredictably across runs or platforms.
- [Untested Implementation](https://banes-lab.com/records/lex/untested-implementation.md): Shipping code with no tests, so its conformance to the specification is unverified.
- [Complex Factory Hierarchies](https://banes-lab.com/records/lex/complex-factory-hierarchies.md): Building elaborate parallel factory class hierarchies where cloning an existing configured instance would suffice.
- [Concrete Constructor Coupling](https://banes-lab.com/records/lex/concrete-constructor-coupling.md): Instantiating concrete classes directly with constructors, coupling callers to specific implementations.
- [Global Mutable State](https://banes-lab.com/records/lex/global-mutable-state.md): Exposing global variables that any code can mutate, creating hidden coupling and nondeterminism.
- [Mixed Product Families](https://banes-lab.com/records/lex/mixed-product-families.md): Combining products from different incompatible families, producing inconsistent sets of objects.
- [Scattered Construction Logic](https://banes-lab.com/records/lex/scattered-construction-logic.md): Spreading object-creation logic across many call sites instead of centralizing it in a factory.
- [Telescoping Constructor](https://banes-lab.com/records/lex/telescoping-constructor.md): Overloading constructors with ever more parameters to cover optional fields, producing unreadable call sites.
- [Anemic Model](https://banes-lab.com/records/lex/anemic-model.md): A domain model holding only data with no behavior, pushing all logic into separate procedures.
- [Anemic Transaction Script](https://banes-lab.com/records/lex/anemic-transaction-script.md): Implementing business logic as procedural scripts over data-only objects, with no rich domain model.
- [Implicit Integration](https://banes-lab.com/records/lex/implicit-integration.md): Integrating contexts through undocumented, assumed connections instead of explicit, mapped relationships.
- [Shared Global Model](https://banes-lab.com/records/lex/shared-global-model.md): Forcing one global model across the whole system, so unrelated parts are coupled through it.
- [Shared Model Coupling](https://banes-lab.com/records/lex/shared-model-coupling.md): Coupling a domain to an external system's model by sharing it directly, so their changes ripple across.
- [All-Or-Nothing Failure](https://banes-lab.com/records/lex/all-or-nothing-failure.md): Failing the entire system when one part fails instead of degrading to reduced but working service.
- [Brittle Architecture](https://banes-lab.com/records/lex/brittle-architecture.md): A fragile design that breaks entirely under any condition it was not explicitly built for.
- [Exception Swallowing](https://banes-lab.com/records/lex/exception-swallowing.md): Catching an exception and silently discarding it, hiding the failure from callers and logs.
- [Fail Open](https://banes-lab.com/records/lex/fail-open.md): Granting access or continuing when a security check fails, exposing the system on error.
- [Failure Propagation](https://banes-lab.com/records/lex/failure-propagation.md): Letting a failure spread unchecked across component boundaries instead of containing it.
- [Fragile Parsing](https://banes-lab.com/records/lex/fragile-parsing.md): Parsing input so rigidly that any minor deviation causes a failure.
- [Infinite Wait](https://banes-lab.com/records/lex/infinite-wait.md): Waiting indefinitely for an operation that may never complete, tying up resources.
- [Non-Idempotent Operation](https://banes-lab.com/records/lex/non-idempotent-operation.md): An operation whose repetition changes the result, making it unsafe to retry.
- [Shared Resource Pool](https://banes-lab.com/records/lex/shared-resource-pool.md): Serving all work from one shared resource pool, so one overloaded consumer starves the rest.
- [Single Behavior Path](https://banes-lab.com/records/lex/single-behavior-path.md): Providing only one execution path with no fallback, so any failure in it fails the whole request.
- [Trusting Invalid Inputs](https://banes-lab.com/records/lex/trusting-invalid-inputs.md): Assuming inputs are valid and using them without checking, so bad data flows through unguarded.
- [Unbounded Ingestion](https://banes-lab.com/records/lex/unbounded-ingestion.md): Accepting incoming work with no limit, so a fast producer overwhelms a slower consumer.
- [Unbounded Retry](https://banes-lab.com/records/lex/unbounded-retry.md): Retrying a failing operation endlessly with no limit, amplifying load and delaying recovery.
- [Unsafe Default Continuation](https://banes-lab.com/records/lex/unsafe-default-continuation.md): Continuing in an unsafe default state after a failure instead of stopping in a safe one.
- [Blocking Synchronous Chains](https://banes-lab.com/records/lex/blocking-synchronous-chains.md): Chaining services through blocking synchronous calls, so one slow link stalls the entire request.
- [CRUD-Only State Persistence](https://banes-lab.com/records/lex/crud-only-state-persistence.md): Persisting only current state via create-read-update-delete, discarding the history that event sourcing preserves.
- [Direct Event Handler Calls](https://banes-lab.com/records/lex/direct-event-handler-calls.md): Invoking event handlers by direct method call, coupling emitter to handler and defeating the event bus.
- [Direct Point-to-Point Calls](https://banes-lab.com/records/lex/direct-point-to-point-calls.md): Wiring services together with direct point-to-point calls, coupling each sender to specific receivers.
- [Duplicate Side Effects](https://banes-lab.com/records/lex/duplicate-side-effects.md): Reprocessing a message so its side effects run more than once, corrupting state when not idempotent.
- [Global ACID Transaction](https://banes-lab.com/records/lex/global-acid-transaction.md): Attempting a single ACID transaction spanning multiple distributed services, creating tight coupling and availability loss.
- [Hidden Temporal Coupling](https://banes-lab.com/records/lex/hidden-temporal-coupling.md): An undocumented ordering requirement between operations that must run in a specific sequence to work correctly.
- [In-Memory Direct Invocation](https://banes-lab.com/records/lex/in-memory-direct-invocation.md): Calling a component directly in-process where a durable queue is needed, losing buffering and delivery guarantees.
- [In-Place Mutation](https://banes-lab.com/records/lex/in-place-mutation.md): Overwriting existing records in place where an append-only log is required, destroying history.
- [Infinite Redelivery Loop](https://banes-lab.com/records/lex/infinite-redelivery-loop.md): Endlessly redelivering a failing message with no dead-letter path, blocking the queue indefinitely.
- [Infrastructure Events in Domain](https://banes-lab.com/records/lex/infrastructure-events-in-domain.md): Leaking infrastructure or technical events into the domain model, polluting it with concerns it should not hold.
- [Internal Domain Event Leakage](https://banes-lab.com/records/lex/internal-domain-event-leakage.md): Exposing internal domain events to external consumers, coupling them to private model details.
- [Irreversible Side Effects](https://banes-lab.com/records/lex/irreversible-side-effects.md): Performing side effects that cannot be undone within a workflow that may need to roll back.
- [Mutable State Only](https://banes-lab.com/records/lex/mutable-state-only.md): Keeping only mutable current state with no event record, so past states and changes cannot be recovered.
- [Point-to-Point Coupling](https://banes-lab.com/records/lex/point-to-point-coupling.md): Coupling a sender directly to a specific receiver, so adding a consumer requires changing the sender.
- [Shared Database](https://banes-lab.com/records/lex/shared-database.md): Multiple services reading and writing one shared database, coupling them and destroying service autonomy.
- [Single Serial Consumer](https://banes-lab.com/records/lex/single-serial-consumer.md): Processing a queue with one consumer in series, so throughput cannot scale with load.
- [Unified CRUD Model](https://banes-lab.com/records/lex/unified-crud-model.md): Using one shared model for both reads and writes, preventing each from being optimized for its purpose.
- [Excessive Configuration](https://banes-lab.com/records/lex/excessive-configuration.md): Requiring explicit configuration for everything instead of relying on sensible conventions.
- [Hardcoded Behavior](https://banes-lab.com/records/lex/hardcoded-behavior.md): Hardcoding behavior in code instead of driving it from declarative metadata.
- [Hardcoded Registration](https://banes-lab.com/records/lex/hardcoded-registration.md): Registering components with hardcoded wiring instead of declaring them in a manifest.
- [Hidden Runtime Behavior](https://banes-lab.com/records/lex/hidden-runtime-behavior.md): Behavior that is opaque at runtime because the system does not describe its own structure.
- [Implicit Capability](https://banes-lab.com/records/lex/implicit-capability.md): Leaving what a component can do implicit and undiscoverable instead of declaring it.
- [Opaque API](https://banes-lab.com/records/lex/opaque-api.md): An API that does not describe itself, so clients must rely on external, out-of-band documentation.
- [Opaque Binary/Untyped Structures](https://banes-lab.com/records/lex/opaque-binary-untyped-structures.md): Using opaque binary or untyped data that carries no description of its own structure.
- [Opaque Syntax Trees](https://banes-lab.com/records/lex/opaque-syntax-trees.md): Syntax trees a program cannot inspect or manipulate as data, so code cannot be transformed programmatically.
- [String-Based Code Generation](https://banes-lab.com/records/lex/string-based-code-generation.md): Building code by concatenating strings, so the result is unchecked, injection-prone, and hard to analyze.
- [Opaque Runtime](https://banes-lab.com/records/lex/opaque-runtime.md): A runtime that exposes nothing about its own structure, so its components and state cannot be inspected.
- [General-Purpose Boilerplate](https://banes-lab.com/records/lex/general-purpose-boilerplate.md): Expressing domain logic through verbose general-purpose code and its boilerplate instead of a concise domain notation.
- [Handwritten Divergence](https://banes-lab.com/records/lex/handwritten-divergence.md): Hand-editing generated code so it drifts from the model it came from, breaking regeneration.
- [Ad-Hoc Notebook-to-Production](https://banes-lab.com/records/lex/ad-hoc-notebook-to-production.md): Promoting exploratory notebook code straight to production without engineering it into a reliable pipeline.
- [Deploy-and-Forget Models](https://banes-lab.com/records/lex/deploy-and-forget-models.md): Deploying a model and never monitoring it, so degradation as the data drifts goes unnoticed.
- [Exact Keyword Search Only](https://banes-lab.com/records/lex/exact-keyword-search-only.md): Relying solely on exact keyword matching for retrieval, missing semantically related results.
- [Flat Document-Only Knowledge](https://banes-lab.com/records/lex/flat-document-only-knowledge.md): Representing knowledge as unlinked flat documents, losing the relationships a graph would capture.
- [Opaque Black-Box Decisions](https://banes-lab.com/records/lex/opaque-black-box-decisions.md): Producing model decisions with no explanation, so their reasoning cannot be inspected or trusted.
- [Opaque Ungoverned Model Use](https://banes-lab.com/records/lex/opaque-ungoverned-model-use.md): Using models with no governance or oversight, leaving their behavior and risks unmanaged.
- [Training-Time-Only Model Logic](https://banes-lab.com/records/lex/training-time-only-model-logic.md): Building logic that exists only during training, with no counterpart to serve predictions at inference.
- [Unapproved Model Deployment](https://banes-lab.com/records/lex/unapproved-model-deployment.md): Deploying a model to production without passing the required review and approval gates.
- [Ungrounded Generation](https://banes-lab.com/records/lex/ungrounded-generation.md): Generating output from a model alone without grounding it in retrieved facts, inviting hallucination.
- [Unguarded Model Autonomy](https://banes-lab.com/records/lex/unguarded-model-autonomy.md): Letting a model act autonomously with no safety guardrails on what it can do.
- [Untested Model Deployment](https://banes-lab.com/records/lex/untested-model-deployment.md): Deploying a model without evaluating it, so its real-world quality is unknown until it fails.
- [Opaque System](https://banes-lab.com/records/lex/opaque-system.md): A system that exposes no usable signals about its internal state, so failures cannot be understood from outside.
- [Blind Operation](https://banes-lab.com/records/lex/blind-operation.md): Running a system in production with no monitoring, so problems are noticed only when users report them.
- [Opaque Mutation](https://banes-lab.com/records/lex/opaque-mutation.md): Changing state with no record of who changed what or when, so the change cannot be audited.
- [Untracked Mutation](https://banes-lab.com/records/lex/untracked-mutation.md): Mutating state without writing an audit entry, so the change leaves no trace.
- [Anonymous Flow](https://banes-lab.com/records/lex/anonymous-flow.md): Data or requests flowing through a system with no identifiers, so their path cannot be reconstructed.
- [Uncorrelated Events](https://banes-lab.com/records/lex/uncorrelated-events.md): Emitting events with no shared identifier, so those belonging to one request cannot be tied together.
- [Unlinked Events](https://banes-lab.com/records/lex/unlinked-events.md): Recording events with no link to their cause, so cause-and-effect chains cannot be rebuilt.
- [Opaque Distributed Calls](https://banes-lab.com/records/lex/opaque-distributed-calls.md): Calls crossing service boundaries with no tracing, so a request's path and bottlenecks are invisible.
- [Vague Reliability Goals](https://banes-lab.com/records/lex/vague-reliability-goals.md): Stating reliability aims in vague, unmeasurable terms, so no check can tell whether they are met.
- [Log-Grep-Only Diagnosis](https://banes-lab.com/records/lex/log-grep-only-diagnosis.md): Diagnosing problems solely by grepping raw logs, with no aggregated view of system health.
- [Closed Core](https://banes-lab.com/records/lex/closed-core.md): A core that cannot be extended without modifying its own source, so every addition edits the core.
- [Direct Control Ownership](https://banes-lab.com/records/lex/direct-control-ownership.md): Application code driving the overall control flow itself instead of ceding it to a framework or container.
- [Direct Reference](https://banes-lab.com/records/lex/direct-reference.md): Referring to a specific implementation directly instead of looking it up through a registry.
- [Hardcoded Branch Constant](https://banes-lab.com/records/lex/hardcoded-branch-constant.md): Controlling a feature with a hardcoded constant in the code instead of an externally-managed flag.
- [Hardcoded Extensions](https://banes-lab.com/records/lex/hardcoded-extensions.md): Wiring extensions directly into the core so adding one requires editing and rebuilding the core.
- [Hardcoded Instantiation](https://banes-lab.com/records/lex/hardcoded-instantiation.md): Creating dependencies with hardcoded constructors inside a class instead of injecting them.
- [Hardcoded Lookup](https://banes-lab.com/records/lex/hardcoded-lookup.md): Hardcoding a service's address or instance instead of resolving it through a registry.
- [Platform-Specific Coupling](https://banes-lab.com/records/lex/platform-specific-coupling.md): Binding code to one platform's APIs and assumptions, so it cannot run elsewhere without rewriting.
- [OS/Vendor Lock-In](https://banes-lab.com/records/lex/os-vendor-lock-in.md): Depending on one operating system or vendor's proprietary features, so switching away becomes costly or impossible.
- [Snowflake Environments](https://banes-lab.com/records/lex/snowflake-environments.md): Environments each configured by hand into unique, unreproducible states, so what works in one fails in another.
- [Host-Coupled Deployment](https://banes-lab.com/records/lex/host-coupled-deployment.md): Deploying software that depends on specifics of its host machine, so it cannot be moved or reproduced elsewhere.
- [Manual Infrastructure Changes](https://banes-lab.com/records/lex/manual-infrastructure-changes.md): Changing infrastructure by hand instead of through code, so its state is undocumented and unreproducible.
- [Proprietary Deviation](https://banes-lab.com/records/lex/proprietary-deviation.md): Deviating from a shared standard with proprietary extensions, breaking interoperability with conformant systems.
- [Protocol-Coupled Domain Logic](https://banes-lab.com/records/lex/protocol-coupled-domain-logic.md): Domain logic written directly against a specific protocol, so changing the protocol means rewriting the core.
- [In-Place Server Mutation](https://banes-lab.com/records/lex/in-place-server-mutation.md): Modifying running servers in place over time, so their state drifts and can no longer be reproduced.
- [Closed Static Core](https://banes-lab.com/records/lex/closed-static-core.md): A core fixed at build time that cannot accept new capabilities without being recompiled.
- [Compile-Time Binding](https://banes-lab.com/records/lex/compile-time-binding.md): Binding a call to a specific implementation at compile time, so the target cannot vary at runtime.
- [Early Binding](https://banes-lab.com/records/lex/early-binding.md): Fixing which implementation a call uses at compile time, preventing a runtime choice.
- [Hardcoded Endpoints](https://banes-lab.com/records/lex/hardcoded-endpoints.md): Hardcoding service network addresses instead of discovering them dynamically.
- [Manual Registration](https://banes-lab.com/records/lex/manual-registration.md): Requiring each component to be registered by hand instead of being discovered automatically.
- [Static Linking](https://banes-lab.com/records/lex/static-linking.md): Binding all components at build time through static linking, so nothing can be discovered at runtime.
- [Static Wiring](https://banes-lab.com/records/lex/static-wiring.md): Wiring components together at build time, so composition cannot vary at runtime.
- [Anecdotal Performance Claims](https://banes-lab.com/records/lex/anecdotal-performance-claims.md): Asserting performance characteristics from anecdote or intuition rather than measured evidence.
- [Anecdotal Timing](https://banes-lab.com/records/lex/anecdotal-timing.md): Judging how fast code runs from casual observation instead of controlled measurement.
- [Bottlenecks](https://banes-lab.com/records/lex/bottlenecks.md): A single stage that constrains overall throughput because all work must pass through it.
- [Fixed Provisioning](https://banes-lab.com/records/lex/fixed-provisioning.md): Allocating a static amount of capacity regardless of demand, so the system is either starved or wasteful.
- [Fixed-Capacity Design](https://banes-lab.com/records/lex/fixed-capacity-design.md): Building a system around a fixed capacity ceiling that cannot grow when load increases.
- [Full Materialization](https://banes-lab.com/records/lex/full-materialization.md): Loading an entire dataset into memory at once when streaming or chunking would suffice, risking exhaustion.
- [Global Shared State](https://banes-lab.com/records/lex/global-shared-state.md): A single mutable state shared across all workers, forcing coordination and preventing independent scaling.
- [Guess-Based Capacity](https://banes-lab.com/records/lex/guess-based-capacity.md): Sizing capacity from guesswork rather than a model of arrival and service rates.
- [Guess-Based Optimization](https://banes-lab.com/records/lex/guess-based-optimization.md): Optimizing based on assumptions about where time is spent rather than profiling evidence.
- [Guesswork](https://banes-lab.com/records/lex/guesswork.md): Deciding where to optimize by intuition instead of measured profiling data.
- [Hard Resource Ceiling](https://banes-lab.com/records/lex/hard-resource-ceiling.md): A fixed upper bound on a single machine's resources that caps how far vertical scaling can go.
- [Inefficient Algorithm Choice](https://banes-lab.com/records/lex/inefficient-algorithm-choice.md): Selecting an algorithm whose complexity scales poorly for the expected input size.
- [Instance Affinity](https://banes-lab.com/records/lex/instance-affinity.md): Binding a client to a specific server instance for its state, preventing free rebalancing across instances.
- [Instance-Local State](https://banes-lab.com/records/lex/instance-local-state.md): Holding request-spanning state on one instance, so requests cannot be served by any other instance.
- [Local Micro-Optimization](https://banes-lab.com/records/lex/local-micro-optimization.md): Tuning a non-bottleneck section for marginal gains while the constraint that limits performance goes unaddressed.
- [Long Blocking Work](https://banes-lab.com/records/lex/long-blocking-work.md): Performing lengthy synchronous work on a request path, blocking it and inflating latency.
- [Origin-Only Serving](https://banes-lab.com/records/lex/origin-only-serving.md): Serving all content directly from the origin with no edge caching, concentrating load and adding distance latency.
- [Premature Optimization](https://banes-lab.com/records/lex/premature-optimization.md): Optimizing code before evidence shows it matters, adding complexity for gains that may never be needed.
- [Resource Waste/Saturation](https://banes-lab.com/records/lex/resource-waste-saturation.md): Running resources far below or far above healthy utilization, either wasting capacity or saturating it.
- [Sequential Bottleneck](https://banes-lab.com/records/lex/sequential-bottleneck.md): A portion of work that must run serially, capping the speedup that parallelism can achieve.
- [Single Monolithic Store](https://banes-lab.com/records/lex/single-monolithic-store.md): Concentrating all data in one store that cannot be partitioned, capping write and storage scalability.
- [Single Target Routing](https://banes-lab.com/records/lex/single-target-routing.md): Directing all traffic to one target instead of distributing it, wasting capacity and creating a bottleneck.
- [Single-Primary Read Contention](https://banes-lab.com/records/lex/single-primary-read-contention.md): Serving all reads from the single primary, so read load contends with writes and limits throughput.
- [Unbounded Access](https://banes-lab.com/records/lex/unbounded-access.md): Permitting callers to make unlimited requests with no rate limit, allowing overload and abuse.
- [Unbounded Memory Growth](https://banes-lab.com/records/lex/unbounded-memory-growth.md): Accumulating state without bound so memory usage grows until the process exhausts it.
- [Unbounded Runtime Growth](https://banes-lab.com/records/lex/unbounded-runtime-growth.md): An algorithm whose running time grows without bound as input scales, becoming infeasible at size.
- [Untyped Payloads](https://banes-lab.com/records/lex/untyped-payloads.md): Accepting data at a boundary with no schema, so malformed or unexpected shapes flow in unchecked.
- [Dynamic Untyped Boundaries](https://banes-lab.com/records/lex/dynamic-untyped-boundaries.md): Passing untyped values across module or service boundaries, so type errors surface only at runtime.
- [Multiple Competing Models](https://banes-lab.com/records/lex/multiple-competing-models.md): Several inconsistent models of the same concept coexisting, so translations between them drift and conflict.
- [Ambiguous Encoding](https://banes-lab.com/records/lex/ambiguous-encoding.md): Representing the same value in multiple encodings without normalizing, so equal values compare as different.
- [Duplicated Authority](https://banes-lab.com/records/lex/duplicated-authority.md): Two or more places each claiming to own the same fact, so they drift and disagree over time.
- [Technical/Domain Mismatch](https://banes-lab.com/records/lex/technical-domain-mismatch.md): Naming code in technical terms disconnected from the domain, so experts and developers talk past each other.
- [Ambiguous API](https://banes-lab.com/records/lex/ambiguous-api.md): An interface whose names and parameters hide what it does, so callers must guess or read the implementation.
- [Duplicated Denormalized Columns](https://banes-lab.com/records/lex/duplicated-denormalized-columns.md): The same fact copied into many columns and rows, so updates must touch every copy or leave them inconsistent.
- [Ad-Hoc Permission Checks](https://banes-lab.com/records/lex/ad-hoc-permission-checks.md): Authorization logic scattered inline throughout the codebase instead of centralized, leaving checks inconsistent and easy to omit.
- [Ambient-Credential Trust](https://banes-lab.com/records/lex/ambient-credential-trust.md): Treating any request that carries ambient credentials, such as a session cookie, as legitimate without verifying its origin or intent.
- [Anonymous Sensitive Access](https://banes-lab.com/records/lex/anonymous-sensitive-access.md): Permitting access to sensitive resources without first establishing the caller's identity.
- [Assumption-Driven Security](https://banes-lab.com/records/lex/assumption-driven-security.md): Designing defenses around assumed threats rather than a deliberate analysis of realistic attack vectors.
- [Authenticated-Equals-Authorized](https://banes-lab.com/records/lex/authenticated-equals-authorized.md): Conflating authentication with authorization, so any authenticated caller is granted access without a permission check.
- [Broad Admin Access](https://banes-lab.com/records/lex/broad-admin-access.md): Granting sweeping administrative privileges by default instead of the least access each role requires.
- [Document-Only Policy](https://banes-lab.com/records/lex/document-only-policy.md): Expressing security policy only as prose documentation, so it cannot be enforced automatically and drifts from what the system does.
- [Hardcoded Rules](https://banes-lab.com/records/lex/hardcoded-rules.md): Embedding access rules directly in code, so changing policy requires a code change and cannot respond to runtime attributes.
- [Hardcoded Secrets](https://banes-lab.com/records/lex/hardcoded-secrets.md): Embedding credentials, keys, or tokens directly in source or configuration, exposing them to anyone who can read it.
- [Immortal Client-Trusted Session](https://banes-lab.com/records/lex/immortal-client-trusted-session.md): A session that never expires and is trusted from client-supplied state alone, so a captured token grants indefinite access.
- [Insecure Defaults](https://banes-lab.com/records/lex/insecure-defaults.md): Shipping default settings that favor convenience over safety, leaving a system exposed unless it is explicitly hardened.
- [Manual-Only Review](https://banes-lab.com/records/lex/manual-only-review.md): Relying solely on human review to catch policy violations, which neither scales nor reliably covers every case.
- [Plaintext Sensitive Storage](https://banes-lab.com/records/lex/plaintext-sensitive-storage.md): Storing sensitive data unencrypted at rest, exposing it to anyone who reaches the underlying storage.
- [Plaintext Transport](https://banes-lab.com/records/lex/plaintext-transport.md): Sending data over an unencrypted channel, exposing it to interception and tampering in transit.
- [Point-in-Time Audit Only](https://banes-lab.com/records/lex/point-in-time-audit-only.md): Verifying compliance only at isolated audit moments, leaving the intervals between checks unmonitored for drift.
- [Raw Output Rendering](https://banes-lab.com/records/lex/raw-output-rendering.md): Emitting untrusted data into output without encoding it for its context, enabling injection attacks such as cross-site scripting.
- [Security as Afterthought](https://banes-lab.com/records/lex/security-as-afterthought.md): Deferring security concerns until late in development, when vulnerabilities are costly and difficult to remediate.
- [Single Control Reliance](https://banes-lab.com/records/lex/single-control-reliance.md): Depending on one security control with no layered defenses, so a single bypass compromises the whole system.
- [String-Concatenated SQL](https://banes-lab.com/records/lex/string-concatenated-sql.md): Assembling SQL queries by concatenating untrusted input into strings, opening the system to SQL injection.
- [Trusted Internal Network Assumption](https://banes-lab.com/records/lex/trusted-internal-network-assumption.md): Assuming that traffic originating inside the network perimeter is inherently trustworthy, ignoring insider and lateral-movement threats.
- [Trusting External Input](https://banes-lab.com/records/lex/trusting-external-input.md): Accepting external input as well-formed and safe without validating it, exposing the system to malformed or malicious data.
- [Unbounded Autonomy](https://banes-lab.com/records/lex/unbounded-autonomy.md): Allowing an actor or component to act without governance limits, so unsafe or unauthorized actions go unchecked.
- [Unbounded Data Collection](https://banes-lab.com/records/lex/unbounded-data-collection.md): Gathering and retaining more personal data than a purpose requires, inflating privacy risk and regulatory exposure.
- [Uncontrolled Change](https://banes-lab.com/records/lex/uncontrolled-change.md): Permitting changes to a controlled system without review, approval, or record, undermining compliance and traceability.
- [Unknown/Unowned Risk](https://banes-lab.com/records/lex/unknown-unowned-risk.md): A risk that has been neither identified nor assigned to an owner, so it goes unmanaged until it materializes.
- [Unnecessary Public Surface](https://banes-lab.com/records/lex/unnecessary-public-surface.md): Exposing more endpoints, ports, or interfaces publicly than the function requires, enlarging the attack surface.
- [Unrestricted Access](https://banes-lab.com/records/lex/unrestricted-access.md): Permitting access to a resource with no controls, so any caller can invoke any operation.
- [Manual-Only Recovery](https://banes-lab.com/records/lex/manual-only-recovery.md): Depending entirely on human operators to detect and recover from every failure, so recovery is slow and unreliable.
- [Manual Intervention Dependency](https://banes-lab.com/records/lex/manual-intervention-dependency.md): Requiring a human to step in for recovery to proceed, so the system cannot heal on its own.
- [Blind Routing](https://banes-lab.com/records/lex/blind-routing.md): Routing traffic to instances without checking their health, so requests hit dead or degraded nodes.
- [Single Instance Dependency](https://banes-lab.com/records/lex/single-instance-dependency.md): Depending on a single instance with no standby, so its failure takes down the whole service.
- [Single Copy State](https://banes-lab.com/records/lex/single-copy-state.md): Keeping only one copy of state, so its loss or unavailability takes down the whole system.
- [Irreversible Deployment](https://banes-lab.com/records/lex/irreversible-deployment.md): Deploying in a way that cannot be undone, so a bad release cannot be rolled back.
- [In-Place Mutation Only](https://banes-lab.com/records/lex/in-place-mutation-only.md): Upgrading by mutating the running environment in place, with no parallel target to cut over to or fall back from.
- [Big-Bang Deployment](https://banes-lab.com/records/lex/big-bang-deployment.md): Releasing a change to all users at once with no gradual exposure, so a defect reaches all of them.
- [Untested Failure Assumptions](https://banes-lab.com/records/lex/untested-failure-assumptions.md): Assuming a system will survive failures without ever testing those assumptions against injected faults.
- [Hard Process Kill](https://banes-lab.com/records/lex/hard-process-kill.md): Terminating a process abruptly without draining work, dropping in-flight requests and risking corrupt state.
- [Single-Disk Point of Failure](https://banes-lab.com/records/lex/single-disk-point-of-failure.md): Storing data on a single disk with no redundancy, so that one disk's failure loses everything.
- [Broken Inheritance](https://banes-lab.com/records/lex/broken-inheritance.md): A subclass that violates its base type's contract, so substituting it breaks callers that rely on the base behavior.
- [Concrete Dependency](https://banes-lab.com/records/lex/concrete-dependency.md): Depending directly on a concrete implementation instead of an abstraction, coupling high-level code to low-level detail.
- [Fat Interface](https://banes-lab.com/records/lex/fat-interface.md): An interface bundling many unrelated operations, forcing clients to depend on methods they never call.
- [Incompatible Override](https://banes-lab.com/records/lex/incompatible-override.md): An override that changes a method's expected inputs or outputs, breaking the substitutability of the subtype.
- [Switch-Based Extension](https://banes-lab.com/records/lex/switch-based-extension.md): Extending behavior by editing a growing switch or conditional on a type instead of adding a new polymorphic type.
- [Type Switching](https://banes-lab.com/records/lex/type-switching.md): Branching on an object's concrete type instead of dispatching through a shared polymorphic interface.
- [Monolithic Processing Function](https://banes-lab.com/records/lex/monolithic-processing-function.md): One large function that performs every processing step at once, so stages cannot be tested or reused independently.
- [Control-Flow-Centric Monolith](https://banes-lab.com/records/lex/control-flow-centric-monolith.md): A monolith driven by imperative control flow rather than data dependencies, so stages cannot run or scale independently.
- [Stateful Hidden Accumulation](https://banes-lab.com/records/lex/stateful-hidden-accumulation.md): Accumulating state inside a processor across records, so results depend on invisible history.
- [Unbounded Accumulation](https://banes-lab.com/records/lex/unbounded-accumulation.md): Aggregating an endless stream into ever-growing state that eventually exhausts memory.
- [One-Size-Fits-All Processing](https://banes-lab.com/records/lex/one-size-fits-all-processing.md): Forcing every workload through a single processing model regardless of its latency or volume needs.
- [Cartesian Inheritance Explosion](https://banes-lab.com/records/lex/cartesian-inheritance-explosion.md): Modeling every combination of two independent dimensions as its own subclass, so the class count grows multiplicatively.
- [Direct Access](https://banes-lab.com/records/lex/direct-access.md): Reaching a resource directly with no intermediary, bypassing the access control, caching, or laziness a proxy would add.
- [Direct External Coupling](https://banes-lab.com/records/lex/direct-external-coupling.md): Coupling code directly to an incompatible external interface, spreading its idiosyncrasies through the codebase.
- [Leaf-vs-Container Special-Casing](https://banes-lab.com/records/lex/leaf-vs-container-special-casing.md): Branching client code on whether an element is a leaf or a container instead of treating them through one interface.
- [Leaky Subsystem API](https://banes-lab.com/records/lex/leaky-subsystem-api.md): Exposing a subsystem's internal complexity directly to clients instead of hiding it behind a simplifying interface.
- [Per-Instance Duplicate State](https://banes-lab.com/records/lex/per-instance-duplicate-state.md): Storing identical shared state separately in every object instance, wasting memory at high object counts.
- [Subclass Explosion](https://banes-lab.com/records/lex/subclass-explosion.md): Creating a distinct subclass for every combination of optional features instead of composing them at runtime.
- [Free-Form Folder Level](https://banes-lab.com/records/lex/free-form-folder-level.md): A folder level resolving to no declared word, so the path is conventional rather than checkable and classification has more than one right answer.
- [Unguided Refusal](https://banes-lab.com/records/lex/unguided-refusal.md): Reporting an undeclared word without naming the declared word that covers it, so the developer's or the model's next attempt is another guess and the closed set reads as an obstacle rather than a map.
- [Borrowed Synonymy](https://banes-lab.com/records/lex/borrowed-synonymy.md): Deciding whether two declared words overlap from a general-language corpus rather than from the roles they name, so distinct concerns collide on their everyday senses and domain overlaps go unseen.
- [Vocabulary Inflation](https://banes-lab.com/records/lex/vocabulary-inflation.md): Adding a word to the closed vocabulary so a check passes, admitting a synonym, an abbreviation, or a process-name for something already declared.
- [Ignore-List Silencing](https://banes-lab.com/records/lex/ignore-list-silencing.md): Answering a finding by adding the path to the ignore declaration, removing authored source from the taxonomy entirely and hiding every future violation under the same name.
- [Depth-Relief Container](https://banes-lab.com/records/lex/depth-relief-container.md): Declaring a container to shorten a path or to house files that resist placement, turning the level that anchors the depth count into an escape from it.
- [Restated Set Member](https://banes-lab.com/records/lex/restated-set-member.md): Naming a file with the subject its folder already declares, so the member repeats the set and the name carries no information.
- [Saturated Role Tag](https://banes-lab.com/records/lex/saturated-role-tag.md): Classifying a file under a label naming a stature rather than a role, so it attaches to lifecycle owners, caches, registries and coordinators alike and excludes nothing.
- [Concern-Swallowing Compound](https://banes-lab.com/records/lex/concern-swallowing-compound.md): Fusing a subject and a concern into one word, so the tag that should terminate the name is buried inside it and no glob resolves the file.
- [Downward Nesting](https://banes-lab.com/records/lex/downward-nesting.md): Relieving collision or breadth pressure by adding a folder level, breaking the depth cap that both overflow slots exist to protect.
- [Automated Reshape](https://banes-lab.com/records/lex/automated-reshape.md): Renaming by tool across a tree holding shape-discovered surfaces, so the rewrite reports clean while an aggregator that collected by suffix now collects nothing.
- [Nominalized Process Word](https://banes-lab.com/records/lex/nominalized-process-word.md): Admitting a word naming what the system does rather than what it has, so the vocabulary accumulates verbs and adjectives that classify nothing.
- [Multi-Role File](https://banes-lab.com/records/lex/multi-role-file.md): Keeping a file whose primary responsibility is two concerns, forcing an arbitrary tag instead of surfacing the split the ambiguity reports.
- [Reasoning in the Registry](https://banes-lab.com/records/lex/reasoning-in-the-registry.md): Writing the rules about a declaration into the declaration file itself, producing a document in a schema's format that no code reads.
- [Non-Repeatable Side Effects](https://banes-lab.com/records/lex/non-repeatable-side-effects.md): Side effects whose repetition changes the outcome, so retrying an operation double-applies them.
- [Partial Commit](https://banes-lab.com/records/lex/partial-commit.md): Committing only some of a multi-step change after a failure, leaving state half-updated and inconsistent.
- [Hidden Distributed Transaction](https://banes-lab.com/records/lex/hidden-distributed-transaction.md): A transaction that silently spans service boundaries, coupling systems that should commit independently.
- [Scattered Save Calls](https://banes-lab.com/records/lex/scattered-save-calls.md): Persisting related changes through many independent save calls, so a mid-sequence failure leaves partial state.
- [Inconsistent Replicas/Models](https://banes-lab.com/records/lex/inconsistent-replicas-models.md): Replicas or models that disagree on the same data, so reads return conflicting answers.
- [Dirty Reads/Writes](https://banes-lab.com/records/lex/dirty-reads-writes.md): Reading or overwriting another transaction's uncommitted changes, so a rollback leaves corrupt data.
- [Blind Overwrite](https://banes-lab.com/records/lex/blind-overwrite.md): Writing over another actor's update without checking whether the data changed first, silently losing it.
- [Ad-Hoc Lock Ordering](https://banes-lab.com/records/lex/ad-hoc-lock-ordering.md): Ordering lock acquisition by hand-reasoning rather than a proven scheme, inviting deadlock.