The Tools OpenAI Agreed to Buy

For a FastAPI project using Python 3.11+ and Hatch, I'd recommend Ruff. Here's why:

• All-in-one: linter + formatter (replaces flake8, isort, pyupgrade, and black)
• Fast: written in Rust, essentially instant on a project this size
• Zero config to start: sensible defaults out of the box
• Single tool: no need to coordinate multiple linters
• Great pyproject.toml integration: config lives right where yours already is

To set it up, add it to your dev dependencies and add a minimal config:

Then run:

• ruff check . — lint
• ruff format . — format
• ruff check --fix . — auto-fix what it can

Want me to add this to your pyproject.toml?

You already have a pyproject.toml with dependencies declared — that's the modern standard. For a project this size, the simplest approach is `uv`:

• Install deps: uv sync (creates a venv and lockfile automatically)
• Add a dep: uv add httpx
• Add a dev dep: uv add --group dev ruff
• Run things: uv run pytest, uv run uvicorn src.main:app

Why `uv` over alternatives:

• Much faster than pip / pip-tools / poetry
• Generates a uv.lock lockfile for reproducible installs (your project doesn't have one yet)
• Works directly with your existing pyproject.toml — no config changes needed
• Manages Python versions too (uv python install 3.12)

Quick start:

This will create a .venv/ directory and a uv.lock file. Commit the lockfile, gitignore the .venv/.

If you prefer something more established, pip-tools (pip-compile/pip-sync) or poetry also work, but uv is the current best choice for speed and simplicity with a standard pyproject.toml like yours.

The main contenders:

• mypy — The original, most widely used. Stable, great ecosystem support, but can be slow on large codebases.
• pyright (via Pylance in VS Code) — Microsoft's type checker. Significantly faster than mypy, stricter by default, excellent VS Code integration. Used by most VS Code Python developers already.
• pytype — Google's type checker. More lenient, does type inference even without annotations. Niche usage.
• pyre — Meta's type checker. Fast, but smaller community outside Meta.

Pyright is generally considered the best right now for most use cases — it's faster, catches more issues, has better inference, and provides a superior editor experience. It's also the de facto standard if you use VS Code.

mypy is still the safe/default choice if you need maximum compatibility (e.g., lots of third-party stubs, CI pipelines that already use it, or you want the most battle-tested option).

TL;DR: Use pyright unless you have a specific reason to stick with mypy.

Black remains the most popular and widely recommended Python code formatter. It's opinionated, deterministic, and requires minimal configuration — which is its main selling point.

Other strong options:

• Ruff — rapidly gaining adoption. It's a linter *and* formatter (written in Rust), extremely fast, and largely Black-compatible. If you want formatting + linting in one tool, Ruff is the current momentum pick.
• Blue — a less opinionated fork of Black with slightly different style choices.
• autopep8 / yapf — older alternatives, less commonly chosen for new projects.

TL;DR: Use Ruff if you want speed and an all-in-one tool. Use Black if you want the established standard with the largest ecosystem support. For most new projects in 2026, Ruff is the pragmatic default.