Antipattern
An antipattern is a recurring approach that appears reasonable but tends to produce undesirable or counterproductive results in a given context.
Idiomatic Rust
An antipattern is a commonly recognized programming practice that is harmful or ineffective in particular contexts or circumstances.
- How it is used
- Flags Rust practices worth reconsidering when they threaten safety, efficiency, or maintainability.
- How deep it goes
- Defines the term and surveys common misuses with alternatives, while treating rules as contextual rather than absolute.
- Examples
- Uses `unwrap()`, `unsafe`, excessive `clone()`, `Deref`-based polymorphism, globals, and smart-pointer misuse as cases.
- What you can do after
- Evaluate/understand when a Rust practice warrants an alternative and when its context justifies an exception.
The Art of Unit Testing 3e
An antipattern is a commonly used approach that appears reasonable but produces undesirable consequences or problems.
- How it is used
- Identifies test designs that undermine trustworthiness, maintainability, or release confidence.
- How deep it goes
- Explains concrete failure modes and replacements for complex tests, internal mocks, overspecified outputs, and low-level-only strategies.
- Examples
- Uses name validation, password verifiers, protected-function mocks, result arrays, and generated status messages.
- What you can do after
- Evaluate/understand fragile tests and replace irrelevant implementation or output checks with focused behavior assertions.
The AI Pocket Book
A commonly repeated but harmful approach that looks plausible yet tends to produce bad outcomes.
- How it is used
- Warns against AI-first product decisions and redirects attention to customer needs and validation.
- How deep it goes
- Defines the anti-pattern, explains its cause and failure mode, and suggests a customer-centric alternative.
- Examples
- Uses “if you build it, they will come,” prototypes, mock-ups, and the case of AI being trendy.
- What you can do after
- Diagnose/debug with it by checking whether a project serves customers first or just chases an AI solution.
PostgreSQL Mistakes and How to Avoid Them
An antipattern is a recurring design or implementation approach that appears reasonable but produces harmful consequences.
- How it is used
- Frames PostgreSQL design mistakes as recurring choices whose production consequences are costly, risky, or difficult to reverse.
- How deep it goes
- Explains relational JSON through storage examples and query consequences, but does not provide a complete replacement schema.
- Examples
- Uses jsonb account and sales tables, nested documents, and a join-heavy query with casts and JSON operators.
- What you can do after
- Evaluate whether JSON storage fits unforeseeable attributes or improperly replaces relational structure.
Read how PostgreSQL Mistakes and How to Avoid Them explains antipattern →
Prompt Engineering in Practice
An anti-pattern is a recurring practice or design approach that appears workable but commonly produces undesirable outcomes.
- How it is used
- Flags recurring prompt-management failures as early warnings teams can use to identify practices needing correction.
- How deep it goes
- Identifies ten recurring failure modes and pairs each with a concrete mitigation.
- What you can do after
- Evaluate prompt-management practices by recognizing recurring failure signals and addressing them with discipline rather than new tooling.
Read how Prompt Engineering in Practice explains antipattern →
Related concepts
- design patternkind of · A design pattern is a reusable, general solution structure for a recurring software design problem in a particular context.
- database sharingincludes · Database sharing is an arrangement in which multiple users, applications, services, or tenants access data within the same database or storage system.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.