Loop Anti-Pattern Linter: Finding Hidden Performance Issues in Python

When writing Python code, loop-heavy logic often looks correct but hides performance issues that only show up at scale.

Patterns like repeated membership checks, string concatenation, or nested iteration over the same data can silently increase time complexity. These are easy to miss during development because they do not break functionality, but they can significantly affect runtime as input size grows.

Why This Matters

Most of these patterns are not syntax errors. The code runs correctly, but the performance cost grows with input size.

Because they are subtle, they are rarely caught during code review unless someone is actively looking for them. This is especially relevant in data processing, backend services, and any code that operates on large collections.

What is Loop Anti-Pattern Linter?

This is a static analyzer that scans Python code to detect common loop anti-patterns.

It does not execute the code. Instead, it parses the source using Python’s ast module and identifies inefficient patterns using rule-based detectors.

Each finding includes an estimated slowdown percentage based on Big-O heuristics and a suggestion. Results are ranked so that higher-impact issues appear first.

How It Works

At a high level, the tool processes code in the following steps:

• Accepts a Python file or directory as input
• Parses the code into an Abstract Syntax Tree (AST)
• Runs detectors implemented as NodeVisitor subclasses
• Each detector targets a specific anti-pattern
• Assigns a predefined estimated_slowdown_pct value
• Sorts findings by this value
• Outputs results as a table or JSON

Because the analysis is static and AST-based, it introduces zero runtime overhead.

How the Scoring Works

The scoring is based on Big-O heuristics.

Each pattern is associated with a predefined slowdown estimate based on typical complexity impact. For example, patterns that introduce nested iteration or repeated linear scans are assigned higher percentages.

These values are not derived from runtime benchmarking. They are directional signals to help prioritize fixes.

Findings are sorted by the estimated_slowdown_pct field so that the most impactful issues appear first.

Detected Loop Anti-Patterns

The tool detects a set of common loop inefficiencies and assigns a heuristic slowdown estimate to each:

Example Output

By default, the output includes the fields shown below. When using the --explain flag, an additional explanation field is included.

{
  "file": "src/processor.py",
  "line": 42,
  "pattern": "ListAppendInLoop",
  "estimated_slowdown_pct": 30,
  "suggestion": "Replace with list comprehension"
}

CLI Usage

# Analyze a directory
python loop_antipattern_lint.py ./src

# Analyze a single file
python loop_antipattern_lint.py mymodule.py

# JSON output
python loop_antipattern_lint.py ./src --json

# Filter high-impact issues
python loop_antipattern_lint.py ./src --min-slowdown 30

AI-Powered Explanations

The --explain flag adds natural language explanations to each finding using OpenRouter.

OPENROUTER_API_KEY=... python loop_antipattern_lint.py ./src --explain

This helps explain why a pattern is inefficient and how to improve it.

How I Built This Using NEO

This project started from a simple requirement: identify inefficient loop patterns in Python code and highlight the ones that are likely to impact performance.

Instead of building everything manually, I used NEO to generate an initial version of the tool from a high-level description.

FYI: Neo is a fully autonomous AI engineering agent that can write code and build solutions for AI/ML tasks including AI model evals, prompt optimization and end to end AI pipeline development.

The prompt focused on the expected behavior:

Build a Python CLI tool that analyzes code using AST, detects loop anti-patterns,assigns slowdown estimates based on Big-O heuristics, and outputs ranked results with suggestions.

This produced a working baseline that aligned with the intended functionality of the tool.

From there, the focus was on validating the output and making small adjustments. This included checking that the detected patterns matched expectations, refining the heuristic slowdown values, and ensuring the CLI usage behaved as intended.

This approach made it possible to move from a high-level idea to a functional tool quickly, without manually implementing each part from scratch.

How to Extend This Further with NEO

The current system can be extended in several ways:

• adding new detectors for additional patterns
• refining slowdown estimates
• improving suggestions
• integrating with CI pipelines
• extending analysis to other inefficiencies

These extensions can be approached by describing the required behavior and iterating on the existing implementation using NEO.

Running the Project

pip install -r requirements.txt
python loop_antipattern_lint.py ./src

Final Notes

This tool focuses on identifying inefficiencies that are easy to miss during development but can have a measurable impact as data size grows.

By combining static analysis with cost estimation based on Big-O heuristics, it helps prioritize optimizations that are worth addressing.

The code is at https://github.com/dakshjain-1616/Loop-Anti-Pattern-Linter
You can also build with NEO in your IDE using the VS Code extension or Cursor.