Build1 distinct publisher3 min readPublished
A Rust duplicate-code checker claims 191x to 250x against isolated Pylint. The more useful part of the argument is why R0801 cannot be sharded across CI workers.
The Engineer · Build desk
Compiled by The EngineerSomething wrong?How this is made
The reason R0801 is the check that stayed behind has less to do with Pylint's speed than with the question the rule asks. An unused-import rule can answer from a single file or syntax tree; duplicate detection has to compare source across a corpus, because the copy may sit anywhere else in the tree [6]. So the standard fix for a slow lint stage does not apply. Partitioning files among workers can change the clusters that get detected, which is why some real-world projects have already separated Pylint's duplicate-code checker into its own single-process CI job [7]. Once you have done that, you own a serial stage whose cost tracks the size of the repository, and you are installing a general-purpose linter to feed it.
Invert the maintainer's published ratios and you get the version worth quoting: on those three repositories Arid 2.0 finished in roughly 0.40 to 0.52 percent of the isolated Pylint 4.0.6 time [15]. The gap between the fastest and slowest of the three ratios is about 31 percent [16], narrow enough to read as implementation rather than repository quirk. He is explicit that this is not an argument that Pylint is 200x slower overall, since Pylint runs many checks Arid does not attempt [11], and he says flatly that "written in Rust" is not a benchmark, which is why the comparison is pinned and maintained [12].
What the ratios cannot tell you is whether this is your problem. The comparison is reported as multipliers, with no absolute wall clock for either tool [17]. Two hundred times faster on a stage that takes three seconds is invisible; on a stage that takes six minutes it is the reason your pipeline feels slow. The only number that settles it is your own timing of `pylint --disable=all --enable=duplicate-code .` [4], and the author agrees: if a dedicated R0801 pass is fast enough for your repository, you already have the solution [18].
The unresolved risk is agreement between the two implementations. Both have to decide what counts as similar, and Pylint exposes controls for ignoring comments, docstrings, imports and function signatures when it builds the representation it compares [5]. Two tools can make those decisions differently and report different clusters. The material supplied is about elapsed time, not about output matching on the same source tree [19], and it comes from the person who wrote the replacement.
That still leaves a narrow, defensible case. Duplicated logic multiplies the places that have to be found, changed and tested, a point Pylint's own documentation makes [13], so switching the check off is not the cheap option it looks like. If R0801 is the only reason Pylint is in the pipeline [1], the choice is between one flag and one fewer linter [8].
Ranked by verification strength, evidence, and original report placement.
The author's premise: if you only need Pylint for duplicate-code detection, you do not necessarily need to run Pylint to get it.
Pylint reports duplicated code as R0801, or duplicate-code; it comes from Pylint's similarities checker and looks for similar lines across Python source.
Ruff can replace a large part of the traditional Python linting stack and does so very quickly, but the author was not able to move duplicate-code detection out of Pylint.
Duplicate-code detection can be run on its own with 'pylint --disable=all --enable=duplicate-code .', which the author calls a perfectly reasonable solution if Pylint is already in the project and its performance is acceptable.
A rule such as 'this import is unused' can largely reason about a particular file or syntax tree, while duplicate detection has to compare source across a corpus because code in one file may duplicate code somewhere else entirely.
Cross-file analysis needs a global view of the source being compared; there are real-world projects that separated Pylint's duplicate-code checker into its own single-process CI job because partitioning files among workers can change the detected clusters.
Follow any of these and your For You feed starts watching them — no settings page required.
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Single self-published source; mechanism checkable, performance not
Everything rests on one dev.to post written by the tool's author. The Pylint-side claims (R0801 origin, the disable-all/enable-duplicate-code command, the normalization options) are specific and independently verifiable, which keeps evidence off the floor. The performance claims are the load-bearing part of the headline and are unverifiable from the supplied material: no absolute wall-clock times, no environment or run counts, and no comparison of the findings each tool reports.
Author's own workflow only
The only usage disclosed is the author's own two-command workflow, alongside an Arid 2.0 version reference and his self-run benchmark. No third-party team, repository, package-registry, CI integration or downstream project is named, so observed adoption is effectively limited to the creator.
Multipliers outrun the evidence, though the author volunteers the caveats
A 191x-250x claim is doing the promotional work while the underlying measurement is a self-run serial comparison with no absolute times and no check that Arid reports the same duplicate clusters as R0801. Adoption beyond the author is unobserved. The gap is moderate rather than large because the author narrows the claim himself, explicitly rejects the reading that Pylint is '200x slower', disclaims 'written in Rust' as a benchmark, tells readers to try isolated Pylint first, and states the exact-duplication scope limit.
Tool author publishing his own benchmark
The sole source is written by Arid's creator, promoting his tool as a replacement for a named incumbent check, and the quantitative comparison is one he ran and framed himself under a 'pinned performance campaign'. That is a strong, undisguised promotional incentive; it is partly offset by disclosure of scope limits and by pointing readers at the Pylint-only alternative.
Confident on the mechanism, weak on the numbers
Confidence is moderate: the structural argument about why duplicate detection cannot be sharded across CI workers, and the Pylint-side commands and options, are consistent and checkable. The performance and adoption dimensions rest on one interested source with no absolute measurements, no independent reproduction and a body that is truncated before the baseline workflow is fully described.
build
Arid 2.0 keeps the detector and rebuilds the plumbing around it1 distinct publisher
build
Ruff Does Not Detect Duplicate Code, And That Gap Now Has Its Own Tool1 distinct publisher
build
A JSON parser benchmark that scores refusal as a pass, and why the column order flips1 distinct publisher
build
One pylint warning, two identical lines: astroid #3077 and the generator that ate its fallback1 distinct publisher
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
1 article · August 24, 2026