Index of every page on this site: llms.txt
All skills
github avatar

/ruff-recursive-fix

@f10fdb8 official
by githubgithub/awesome-copilot41k stars
5,399
Run it yourself

Run Ruff checks with optional scope and rule overrides, apply safe and unsafe autofixes iteratively, review each change, and resolve remaining findings with targeted edits or user decisions.

Use this Skill: https://skilld.dev/gh/github/awesome-copilot/ruff-recursive-fix

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈53 tokens for metadata: the name and description. ≈1.5k when used: this file.

Description uses 2.6% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈211 characters, or 2.6%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Ruff Recursive Fix

Overview

Use this skill to enforce code quality with Ruff in a controlled, iterative workflow. It supports:

  • Optional scope limitation to a specific folder.
  • Default project settings from pyproject.toml.
  • Flexible Ruff invocation (uv, direct ruff, python -m ruff, or equivalent).
  • Optional per-run rule overrides (--select, --ignore, --extend-select, --extend-ignore).
  • Automatic safe then unsafe autofixes.
  • Diff review after each fix pass.
  • Recursive repetition until findings are resolved or require a decision.
  • Judicious use of inline # noqa only when suppression is justified.

Inputs

Collect these inputs before running:

  • target_path (optional): folder or file to check. Empty means whole repository.
  • ruff_runner (optional): explicit Ruff command prefix (for example uv run, ruff, python -m ruff, pipx run ruff).
  • rules_select (optional): comma-separated rule codes to enforce.
  • rules_ignore (optional): comma-separated rule codes to ignore.
  • extend_select (optional): extra rules to add without replacing configured defaults.
  • extend_ignore (optional): extra ignored rules without replacing configured defaults.
  • allow_unsafe_fixes (default: true): whether to run Ruff unsafe fixes.
  • ask_on_ambiguity (default: true): always ask the user when multiple valid choices exist.

Command Construction

Build Ruff commands from inputs.

0. Resolve Ruff Runner

Determine a reusable ruff_cmd prefix before building commands.

Resolution order:

  1. If ruff_runner is provided, use it as-is.
  2. Else if uv is available and Ruff is managed through uv, use uv run ruff.
  3. Else if ruff is available on PATH, use ruff.
  4. Else if Python is available and Ruff is installed in that environment, use python -m ruff.
  5. Else use any project-specific equivalent that invokes installed Ruff (for example pipx run ruff), or stop and ask the user.

Use the same resolved ruff_cmd for all check and format commands in the workflow.

Base command:

<ruff_cmd> check

Formatter command:

<ruff_cmd> format

With optional target:

<ruff_cmd> format <target_path>

Add optional target:

<ruff_cmd> check <target_path>

Add optional overrides as needed:

--select <codes>
--ignore <codes>
--extend-select <codes>
--extend-ignore <codes>

Examples:

# Full project with defaults from pyproject.toml
ruff check

# One folder with defaults
python -m ruff check src/models

# Override to skip docs and TODO-like rules for this run
uv run ruff check src --extend-ignore D,TD

# Check only selected rules in a folder
ruff check src/data --select F,E9,I

Workflow

1. Baseline Analysis

  1. Run <ruff_cmd> check with the selected scope and options.
  2. Classify findings by type:
    • Autofixable safe.
    • Autofixable unsafe.
    • Not autofixable.
  3. If no findings remain, stop.

2. Safe Autofix Pass

  1. Run Ruff with --fix using the same scope/options.
  2. Review resulting diff carefully for semantic correctness and style consistency.
  3. Run <ruff_cmd> format on the same scope.
  4. Re-run <ruff_cmd> check to refresh remaining findings.

3. Unsafe Autofix Pass

Run only if findings remain and allow_unsafe_fixes=true.

  1. Run Ruff with --fix --unsafe-fixes using the same scope/options.
  2. Review resulting diff carefully, prioritizing behavior-sensitive edits.
  3. Run <ruff_cmd> format on the same scope.
  4. Re-run <ruff_cmd> check.

4. Manual Remediation Pass

For remaining findings:

  1. Fix directly in code when there is a clear, safe correction.
  2. Keep edits minimal and local.
  3. Run <ruff_cmd> format on the same scope.
  4. Re-run <ruff_cmd> check.

5. Ambiguity Policy

If there are multiple valid solutions at any step, always ask the user before proceeding. Do not choose silently between equivalent options.

6. Suppression Decision (# noqa)

Use suppression only when all conditions are true:

  • The rule conflicts with required behavior, public API, framework conventions, or readability goals.
  • Refactoring would be disproportionate to the value of the rule.
  • The suppression is narrow and specific (single line, explicit code when possible).

Guidelines:

  • Prefer # noqa: <RULE> over broad # noqa.
  • Add a brief reason comment for non-obvious suppressions.
  • If two or more valid outcomes exist, always ask the user which option to prefer.

7. Recursive Loop and Stop Criteria

Repeat steps 2 to 6 until one of these outcomes:

  • <ruff_cmd> check returns clean.
  • Remaining findings require architectural/product decisions.
  • Remaining findings are intentionally suppressed with documented rationale.
  • Repeated loop makes no progress.

Each loop iteration must include <ruff_cmd> format before the next <ruff_cmd> check.

When no progress is detected:

  1. Summarize blocked rules and affected files.
  2. Present valid options and trade-offs.
  3. Ask the user to choose.

Quality Gates

Before declaring completion:

  • Ruff returns no unexpected findings for the chosen scope/options.
  • All autofix diffs are reviewed for correctness.
  • No suppression is added without explicit justification.
  • Any unsafe fix with possible behavioral impact is highlighted to the user.
  • Ruff formatting is executed in every iteration.

Output Contract

At the end of execution, report:

  • Scope and Ruff options used.
  • Number of iterations performed.
  • Summary of fixed findings.
  • List of manual fixes.
  • List of suppressions with rationale.
  • Remaining findings, if any, and required user decisions.

Suggested Prompt Starters

  • "Run ruff-recursive-fix on the whole repo with default config."
  • "Run ruff-recursive-fix only on src/models, ignore DOC rules."
  • "Run ruff-recursive-fix on tests with select F,E9,I and no unsafe fixes."
  • "Run ruff-recursive-fix on src/data and ask me before adding any noqa."

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No alerts2mo4 checks · Risk SAFE
  • Gen Agent Trust Hub2mo

    The skill facilitates code linting and formatting using Ruff but contains a command injection surface because it interpolates user-provided inputs directly into shell commands.

  • Socket2mo

    No alerts

  • Snyk2mo

    Risk: LOW · No issues

  • ZeroLeaks7mo

    Score: 93/100 · 2 sections analyzed

Signed by skilld at f10fdb8. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub yesterday.

Activeupdated 8 months ago
  • Python
  • ruff
  • linting
  • code-quality
  • autofix
  • formatting
  • pyproject.toml

README badge

README badge for github/awesome-copilot/ruff-recursive-fix

Runs Ruff checks with optional scope and rule overrides, applies safe and unsafe autofixes iteratively, reviews each change, and resolves remaining findings with targeted edits or user decisions. Supports flexible Ruff invocation methods (uv, direct command, python -m), respects pyproject.toml defaults, and uses inline `# noqa` only when justified.

Generated from the current SKILL.md.

Does this skill apply unsafe fixes automatically?
Only if `allow_unsafe_fixes` is set to true (the default). Unsafe fixes are applied after safe fixes in a separate pass, and all diffs are reviewed before committing.
Can I limit this to a specific folder or file?
Yes. Use the `target_path` input to check a single folder or file. If empty, the skill checks the whole repository.
How does this handle rule conflicts or ambiguous fixes?
When multiple valid solutions exist, the skill always asks the user to choose rather than proceeding silently. The same applies to suppression decisions when justification is unclear.
What Ruff invocation methods does this support?
The skill auto-resolves the Ruff command in order of preference: explicit `ruff_runner` input, `uv run ruff`, direct `ruff`, `python -m ruff`, or project-specific equivalents like `pipx run ruff`.
Does this add noqa suppressions automatically?
No. Suppressions are added only when you explicitly justify them and confirm they meet the criteria: the rule conflicts with required behavior, refactoring is disproportionate, and the suppression is narrow and specific.

Generated from the current SKILL.md. These answers refresh after source changes.