Ruff v0.16.0: 413 Default Rules, Markdown Formatting, and What Zero-Config Linting Means for Python

Ruff shipped v0.16.0 on July 23 -- and it is the most significant default-behavior change in the project's history. The Rust-based Python linter and formatter, now under OpenAI's roof after the Astral acquisition, expanded its default rule set from 59 rules to 413 in a single release. That is a 7x increase in the number of issues Ruff will flag without any configuration file at all.

If you have been using Ruff with a pyproject.toml or .ruff.toml, most of this does not affect you -- your explicit select/extend-select still controls what fires. But if you rely on Ruff's out-of-the-box behavior (or if you onboard new projects and want sensible defaults without debate), this release changes the calculus on what "running Ruff" means.

What Actually Changed#

The headline number is 413 default rules. Ruff's total rule count grew from 708 to 968 since the default set was last touched in v0.1.0, and the team decided that many of the new rules -- including rules from flake8-bugbear (B), pyupgrade (UP), and Ruff's own RUF category -- caught real bugs and deserved to be on by default. The full rule listing lives on the new Default Rules docs page.

Three new features stand out:

Markdown code-block formatting. Ruff can now format Python code blocks inside Markdown files. It recognizes fenced blocks with python, py, python3, py3, pyi, and pycon info strings. Quarto notebooks with {python} fences work too if you configure the .qmd extension mapping. You can suppress formatting with <!-- fmt: off --> HTML comments or exclude Markdown files entirely via extend-exclude.

New ruff: ignore suppression comments. Building on the ruff: disable/ruff: enable range suppression from v0.15, Ruff v0.16 adds ruff: ignore (suppress on the same or next logical line) and ruff: file-ignore (suppress for the whole file). A new --add-ignore CLI flag auto-inserts these comments. In preview mode, rule names work instead of codes: # ruff: ignore[unused-import] instead of # ruff: ignore[F401].

Fixes shown in check and format output. The check and format --check commands now display diffs directly in the default output format -- no more running with --diff separately to see what would change. The format command also supports the full range of output formats now (JSON, GitHub annotations, GitLab code quality).

The release also stabilizes 12 rules from preview, including sorted-min-max (FURB192), none-not-at-end-of-union (RUF036), and too-many-positional-arguments (PLR0917).

What HN Is Saying#

The Hacker News thread (105 points, 46 comments as of writing) split into three camps worth hearing.

The zero-config camp was excited. One commenter ran v0.16 on a file with no config and found it flagged unsorted imports and bare except Exception by default. Another said their new .ruff.toml is now just line-length = 300. The thesis: "413 rules by default means most projects get useful linting without touching the config at all."

The "why no v1.0?" camp pushed back on breaking changes in a 0.x release. A top-voted comment asked: "Why must my poor semver be hurt so!" Others pointed out that semver explicitly allows breaking changes in 0.x minor releases, and referenced Ruff's own versioning policy. The question of when Ruff will hit 1.0 is not new, but it resurfaced with more urgency after the OpenAI acquisition.

The agentic coding angle got real attention. Multiple commenters noted that strong linting matters more when AI agents write the code. One wrote: "With the advent of agentic coding, strong linting is more important than ever." Another raised the counterpoint: AI agents "spend lots of tokens trying to fix a benign issue" and that it is hard to "trust their judgement on code quality." This tension -- rules catch real bugs but also burn agent context on churn -- is the key practical debate for teams running AI coding tools at scale.

A working developer shared a real migration report: upgrading a ~3k line project from v0.15 to v0.16, with linked commits showing what the new rules caught and how the fixes broke down between manual edits and auto-corrections.

Several commenters also noted that Ruff, ty, and uv are all seeing active development post-acquisition, which was not a given after Astral joined OpenAI in March.

Why This Matters for AI-Assisted Development#

Ruff's default-rule expansion arrives at a moment when more Python code is being written by AI agents than ever before. The calculus is different from the pre-agent era:

When a human writes code, they (usually) have some sense of what the linter will flag and can avoid patterns they know will trigger warnings. An LLM generating code has no such internalized linting model -- it produces whatever pattern the training data suggests, lint be damned. That makes the linter the first and often only quality gate before the code reaches a human reviewer.

A 7x increase in default rules changes the character of that gate. On one hand, more rules means more real bugs caught before they ship. The flake8-bugbear rules now enabled by default catch iterator-mutation footguns and subtle except semantics that production incidents are made of. On the other hand, as the HN thread noted, agent token budgets are finite. Every ruff: ignore comment an agent adds to silence a false positive is context that does not go toward the actual feature.

The pragmatic take: for greenfield projects, the v0.16 defaults are an unambiguous improvement. For existing codebases with established configs, they do not change anything. For agent-generated code, the right approach is to run Ruff with the defaults, measure the noise-to-signal ratio, and add explicit select/ignore lines to the project config rather than relying on per-file suppression comments that eat agent context.

The continued active development of Ruff post-Acquisition (ty and uv are also shipping regularly) is a welcome signal for the Python ecosystem. Even under OpenAI ownership, the team is shipping features that benefit all Python developers, not just Codex users.

Continue Reading#

• Astral Joins OpenAI: What It Means for Python Developers -- The original coverage of the acquisition and what it meant for Ruff, uv, and the Python tooling landscape.
• hf-mlinter: Hugging Face's Linter for Transformers Code -- How Hugging Face built an ML-specific linter that runs alongside Ruff, and why the Ruff plugin ecosystem inspired its design.
• Best CLI Tools for AI Development 2026 -- Where Rust-based developer tools like Ruff and uv fit in the modern AI development stack.
• Python Tooling in the AI Era: Haskell to Python Migration Lessons -- A discussion of Python's type and lint tooling landscape, including Ruff's role.

Sources#

• Ruff v0.16.0 release announcement -- Astral blog, July 23, 2026
• Hacker News discussion -- 105 points, 46 comments
• Ruff Default Rules documentation -- The full listing of 413 enabled rules
• Ruff versioning policy -- Semver policy for 0.x releases
• Ruff Changelog: v0.16.0 -- Full changelog on GitHub