Python Anti Patterns

by wshobson46891e7e60daNo licenseListed Oct 8, 2026Updated Oct 8, 2026

Use this skill when reviewing Python code for common anti-patterns to avoid. Use as a checklist when reviewing code, before finalizing implementations, or when debugging issues that might stem from known bad practices.

Instructions onlySoftware DevelopmentLearning & Education
AI-generated overview

Checklist for reviewing Python code against common anti-patterns before finalizing implementations.

What it does
Provides a reference checklist of common Python mistakes and anti-patterns, grouped into infrastructure, architecture, error handling, resource, type safety, and testing categories. Each entry shows a bad example, a suggested fix, and a short explanation. It ends with a quick review checklist and a summary table mapping anti-patterns to fixes.
When to use it
Use it when reviewing Python code before merge, before finalizing an implementation, or when debugging issues that may stem from known bad practices. It also fits establishing team coding standards, refactoring legacy code, and teaching Python best practices.
Requirements
No scripts or tooling required; it is an instructions-only reference document. Code examples mention libraries such as requests, pydantic-settings, httpx, and pytest, but none are needed to read the checklist.

Python Anti-Patterns Checklist

A reference checklist of common mistakes and anti-patterns in Python code. Review this before finalizing implementations to catch issues early.

When to Use This Skill

  • Reviewing code before merge
  • Debugging mysterious issues
  • Teaching or learning Python best practices
  • Establishing team coding standards
  • Refactoring legacy code

Note: This skill focuses on what to avoid. For guidance on positive patterns and architecture, see the python-design-patterns skill.

Infrastructure Anti-Patterns

Scattered Timeout/Retry Logic

python
# BAD: Timeout logic duplicated everywheredef fetch_user(user_id):    try:        return requests.get(url, timeout=30)    except Timeout:        logger.warning("Timeout fetching user")        return None
def fetch_orders(user_id):    try:        return requests.get(url, timeout=30)    except Timeout:        logger.warning("Timeout fetching orders")        return None

Fix: Centralize in decorators or client wrappers.

python
# GOOD: Centralized retry logic@retry(stop=stop_after_attempt(3), wait=wait_exponential())def http_get(url: str) -> Response:    return requests.get(url, timeout=30)

Double Retry

python
# BAD: Retrying at multiple layers@retry(max_attempts=3)  # Application retrydef call_service():    return client.request()  # Client also has retry configured!

Fix: Retry at one layer only. Know your infrastructure's retry behavior.

Hard-Coded Configuration

python
# BAD: Secrets and config in codeDB_HOST = "prod-db.example.com"API_KEY = "sk-12345"
def connect():    return psycopg.connect(f"host={DB_HOST}...")

Fix: Use environment variables with typed settings.

python
# GOODfrom pydantic_settings import BaseSettings
class Settings(BaseSettings):    db_host: str = Field(alias="DB_HOST")    api_key: str = Field(alias="API_KEY")
settings = Settings()

Architecture Anti-Patterns

Exposed Internal Types

python
# BAD: Leaking ORM model to API@app.get("/users/{id}")def get_user(id: str) -> UserModel:  # SQLAlchemy model    return db.query(UserModel).get(id)

Fix: Use DTOs/response models.

python
# GOOD@app.get("/users/{id}")def get_user(id: str) -> UserResponse:    user = db.query(UserModel).get(id)    return UserResponse.from_orm(user)

Mixed I/O and Business Logic

python
# BAD: SQL embedded in business logicdef calculate_discount(user_id: str) -> float:    user = db.query("SELECT * FROM users WHERE id = ?", user_id)    orders = db.query("SELECT * FROM orders WHERE user_id = ?", user_id)    # Business logic mixed with data access    if len(orders) > 10:        return 0.15    return 0.0

Fix: Repository pattern. Keep business logic pure.

python
# GOODdef calculate_discount(user: User, orders: list[Order]) -> float:    # Pure business logic, easily testable    if len(orders) > 10:        return 0.15    return 0.0

Error Handling Anti-Patterns

Bare Exception Handling

python
# BAD: Swallowing all exceptionstry:    process()except Exception:    pass  # Silent failure - bugs hidden forever

Fix: Catch specific exceptions. Log or handle appropriately.

python
# GOODtry:    process()except ConnectionError as e:    logger.warning("Connection failed, will retry", error=str(e))    raiseexcept ValueError as e:    logger.error("Invalid input", error=str(e))    raise BadRequestError(str(e))

Ignored Partial Failures

python
# BAD: Stops on first errordef process_batch(items):    results = []    for item in items:        result = process(item)  # Raises on error - batch aborted        results.append(result)    return results

Fix: Capture both successes and failures.

python
# GOODdef process_batch(items) -> BatchResult:    succeeded = {}    failed = {}    for idx, item in enumerate(items):        try:            succeeded[idx] = process(item)        except Exception as e:            failed[idx] = e    return BatchResult(succeeded, failed)

Missing Input Validation

python
# BAD: No validationdef create_user(data: dict):    return User(**data)  # Crashes deep in code on bad input

Fix: Validate early at API boundaries.

python
# GOODdef create_user(data: dict) -> User:    validated = CreateUserInput.model_validate(data)    return User.from_input(validated)

Resource Anti-Patterns

Unclosed Resources

python
# BAD: File never closeddef read_file(path):    f = open(path)    return f.read()  # What if this raises?

Fix: Use context managers.

python
# GOODdef read_file(path):    with open(path) as f:        return f.read()

Blocking in Async

python
# BAD: Blocks the entire event loopasync def fetch_data():    time.sleep(1)  # Blocks everything!    response = requests.get(url)  # Also blocks!

Fix: Use async-native libraries.

python
# GOODasync def fetch_data():    await asyncio.sleep(1)    async with httpx.AsyncClient() as client:        response = await client.get(url)

Type Safety Anti-Patterns

Missing Type Hints

python
# BAD: No typesdef process(data):    return data["value"] * 2

Fix: Annotate all public functions.

python
# GOODdef process(data: dict[str, int]) -> int:    return data["value"] * 2

Untyped Collections

python
# BAD: Generic list without type parameterdef get_users() -> list:    ...

Fix: Use type parameters.

python
# GOODdef get_users() -> list[User]:    ...

Testing Anti-Patterns

Only Testing Happy Paths

python
# BAD: Only tests success casedef test_create_user():    user = service.create_user(valid_data)    assert user.id is not None

Fix: Test error conditions and edge cases.

python
# GOODdef test_create_user_success():    user = service.create_user(valid_data)    assert user.id is not None
def test_create_user_invalid_email():    with pytest.raises(ValueError, match="Invalid email"):        service.create_user(invalid_email_data)
def test_create_user_duplicate_email():    service.create_user(valid_data)    with pytest.raises(ConflictError):        service.create_user(valid_data)

Over-Mocking

python
# BAD: Mocking everythingdef test_user_service():    mock_repo = Mock()    mock_cache = Mock()    mock_logger = Mock()    mock_metrics = Mock()    # Test doesn't verify real behavior

Fix: Use integration tests for critical paths. Mock only external services.

Quick Review Checklist

Before finalizing code, verify:

  • No scattered timeout/retry logic (centralized)
  • No double retry (app + infrastructure)
  • No hard-coded configuration or secrets
  • No exposed internal types (ORM models, protobufs)
  • No mixed I/O and business logic
  • No bare except Exception: pass
  • No ignored partial failures in batches
  • No missing input validation
  • No unclosed resources (using context managers)
  • No blocking calls in async code
  • All public functions have type hints
  • Collections have type parameters
  • Error paths are tested
  • Edge cases are covered

Common Fixes Summary

Anti-PatternFix
Scattered retry logicCentralized decorators
Hard-coded configEnvironment variables + pydantic-settings
Exposed ORM modelsDTO/response schemas
Mixed I/O + logicRepository pattern
Bare exceptCatch specific exceptions
Batch stops on errorReturn BatchResult with successes/failures
No validationValidate at boundaries with Pydantic
Unclosed resourcesContext managers
Blocking in asyncAsync-native libraries
Missing typesType annotations on all public APIs
Only happy path testsTest errors and edge cases

Source and attribution

Source:wshobson/agentsinplugins/python-development/skills/python-anti-patternsat commit46891e7

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

More from wshobson/agents

Uv Package Manager

wshobson

Reference guide for using the uv Python package manager for dependencies, virtual environments and project workflows.

Software DevelopmentOct 8, 2026

Web Component Design

wshobson

Guides building reusable UI components in React, Vue and Svelte, covering composition patterns, CSS-in-JS choices and component API design.

Software DevelopmentOct 8, 2026

Python Type Safety

wshobson

Guides Python type annotations, generics, protocols, and strict mypy/pyright checking.

Software DevelopmentOct 8, 2026

Visual Design Foundations

wshobson

Guides typography, color, spacing and iconography decisions for cohesive, accessible visual design systems.

Design & CreativeOct 8, 2026

Responsive Design

wshobson

Guides implementation of responsive web layouts using container queries, fluid typography, CSS Grid and breakpoints.

Software DevelopmentOct 8, 2026

Python Resource Management

wshobson

Guides Python developers in managing resources deterministically with context managers, cleanup patterns, and streaming.

Software DevelopmentOct 8, 2026

More in Software Development

Playground

anthropics

Featured

Builds self-contained interactive HTML playgrounds with controls, live preview, and copyable prompt output.

Software Development37Kupdated today

M5 Onboard

anthropics

Featured

Provisions M5Stack ESP32 boards by detecting them on USB, flashing UIFlow 2.0 firmware, and installing a MicroPython app bundle.

Software Development37Kupdated today

Cardputer Buddy

anthropics

Featured

Guides iterating on a Cardputer-Adv MicroPython app bundle: adding apps, pushing files over USB-serial, tailing logs, and running REPL commands.

Software Development37Kupdated today

Dev

microsoft

Featured

Provides development workflow instructions for the playwright-cli repository, covering dependency rolling and release preparation.

Software DevelopmentOct 8, 2026

Dpop Adoption

google

Featured

Guides implementation of OAuth 2.0 DPoP (RFC 9449) sender-constrained refresh tokens for Google's OAuth platform.

Software DevelopmentOct 8, 2026

Web Design Guidelines

vercel-labs

Featured

Reviews UI code against Web Interface Guidelines fetched from a remote source and reports findings as file:line entries.

Software DevelopmentOct 8, 2026