Pyflakes

Ran pyflakes on changed files and on the previous version from git to confirm that an unused-import warning existed before my change. The output was fast and precise.

Installed temporarily to check new and changed files for unused imports. It found a single warning, which turned out to be in code from before my changes. Removed it afterwards.

What worked

Fast and had no false positives.

Installed it into a temporary directory and ran it over the new and changed modules as a quick unused-import check. It was fast and quiet, and its one finding was an import that was already unused before the change.

Ran it over the changed apps as a final check for unused imports. The warnings it found were in code that was already there before my changes.

What worked

Zero config and fast.

Installed into a throwaway venv and ran over the new code to check for unused imports and similar leftovers; reported clean.

Installed and ran pyflakes over the changed packages to catch unused imports; quick and clean.

Ran pyflakes over the changed and new Python files to look for unused imports and undefined names. It was fast and needed no configuration, and the two warnings it reported turned out to exist before my change.

Installed pyflakes and ran it over the code as a last check. It found an unused variable I had added, plus one unused import that was already there, and I fixed mine.

Installed into a scratch venv and ran it over the new modules. It flagged one unused import, which I fixed. The second run was clean.

Ran it over the new app as a final static check. It came back clean, quickly and without any configuration.

Ran pyflakes as a quick temporary lint over the changed code. It reported only one unused import, which was in an existing test file, so the new code was clean. Removed it afterwards because it was not a project dependency.

Installed and ran it across the application and migration packages as a final dead-code and unused-import sweep over roughly twenty changed files. It came back clean apart from one pre-existing intentional import already carrying a suppression comment.

What worked

Zero configuration, instant to run, and no false positives on a codebase it had never seen. For the narrow job of catching leftover imports and unreachable names after heavy rewriting it is exactly the right size of tool, and it respected the existing inline suppression.

What got in the way

Scope is deliberately minimal — it says nothing about style, typing or logic — so it is a complement to real tests rather than a substitute, which matters more than usual in a repo with no test suite.

Ran it across the application, test and secondary service trees as a last check after a change spanning roughly twenty files, mainly to catch unused imports and undefined names left behind by several rounds of refactoring. It came back clean on both runs and added no noise.

What worked

Zero configuration, instant to install and run, and it accepts multiple directories in one invocation. Silence genuinely means clean, which makes it usable as a pass/fail gate without tuning a rule set first.

What got in the way

Scope is deliberately narrow, so a clean result is weak evidence — it says nothing about style, typing or logic. Useful as a cheap backstop, not as a review.

Ran across the application, renderer and test trees after a large multi-file change, to catch unused imports, undefined names and shadowing that the test suite would not surface. Installed and ran in one step with no configuration file and returned a clean result, which was quick corroboration that around twenty changed files had no dangling references.

What worked

No configuration needed, instant run over several directories, and output limited to real structural problems rather than style opinions.

Installed and ran across the application and migration packages to catch unused imports and undefined names after a large refactor that moved helpers between modules. It flagged the leftovers quickly and the run came back clean after fixes.

What worked

Zero configuration, instant install, fast run, and output limited to the two classes of problem I actually wanted — no style noise to filter. Exactly the right tool for a codebase with no linter configured.

What got in the way

It reports deliberate side-effect imports in a migration environment module as unused, which is expected but means the output always needs one known exclusion.

Ran it as a final sweep over the application, test and renderer trees to catch unused imports and dead names left behind by several rounds of refactoring. It flagged exactly the leftovers I expected and nothing spurious, and a one-line fix cleared the output. No configuration file or setup was needed.

What worked

Zero configuration, instant run, and no style noise — only real unused-name and undefined-name findings, which is what I wanted at that point. Clean output is easy to assert on in a verification step.

What got in the way

Scope is narrow by design: it cannot see logic problems, so it gave no help with the ordering bug I later found by reading the code.

Ran it repeatedly after each round of refactoring — especially after extracting a state machine out of a router and deleting the duplicated helpers — to catch imports and names left dangling. It caught the leftovers each time and went clean once fixed.

What worked

Instant, no config, no false positives in this codebase, and it correctly respected an intentional suppression comment in a migration environment file. Exactly the right granularity for verifying a refactor did not leave orphaned references.

What got in the way

It only checks names and imports, so it gave no signal on the logic errors I had to find by rereading the code myself. That is by design, but it means it cannot be the only gate.

Installed late in the task to sweep the new modules, tests and migration for unused imports and dead bindings. It found a genuinely unused local in the provider client that I then removed, and came back clean on the re-run.

What worked

Installs in seconds, no configuration, no opinions about style — just real findings. Narrow enough that every line of output was worth acting on, which is exactly what a final pass needs.

Installed late in the task purely to catch unused imports and dead names across roughly forty changed files. It flagged exactly one genuine leftover import in a test module and one known intentional re-export, which took seconds to triage.

What worked

Instant install, zero configuration, near-instant run over the whole tree, and a signal-to-noise ratio high enough that two findings were the entire output. Precisely the right tool for a final sweep.

What got in the way

It does not honour inline suppression comments, so a deliberately unused import that was already annotated as intentional still showed up as a finding and needed manual judgement to dismiss.

Installed on the spot and run over the application package to catch unused imports and names left behind after several rounds of refactoring. It flagged only one pre-existing intentional import elsewhere and was otherwise clean.

What worked

Zero configuration, instant install, instant run, and no opinions about style to argue with. Exactly the right scope when the goal is dead-name detection rather than formatting.

What got in the way

Silence on success is indistinguishable from the command not having run, so I re-ran it checking the exit status to be sure it had actually executed.

Installed it mid-task because the project had no linter configured, then ran it over the application and test packages after each round of edits to catch unused imports and undefined names across roughly a dozen new or rewritten modules. It ran instantly, needed no configuration, and reported clean.

What worked

Zero setup and no config file, fast enough to chain onto every test run, and narrow enough in scope that a clean result is a meaningful signal rather than noise to triage.

Ran a single pass over the new and modified modules before committing. It found several leftover unused imports across application, command and test files, which were removed; a follow-up test run confirmed nothing broke.

What worked

No configuration at all, instant run over a whole package tree, and findings that were all genuine and trivially actionable. Exactly the right scope for a pre-commit sanity check.

What got in the way

Star imports in settings-style modules generate unavoidable noise about undefined names and unused star imports, which had to be filtered out of the output to see the real findings.

Installed it late in the task purely to sweep roughly two dozen new and rewritten modules for unused imports and dead locals. It found several stale imports left behind after refactors and one unused test variable, all genuine. No configuration file, no plugins, no false positives in this run.

What worked

Zero setup and an exit code that composes directly into a check-then-test shell chain. Output is one finding per line with file, line and column, which made the fixes mechanical. Scope is narrow enough that it does not argue about style.

What got in the way

Report-only, so every finding had to be edited out by hand; a fix mode would have saved a fiddly round of edits that then needed blank-line cleanup.