Build1 distinct publisher2 min readUpdated
A Rust duplicate-code checker for Python claims roughly 219x on the one job Ruff skips and Pylint R0801 does slowly. Version 2 spent its effort on stable finding identity, not the algorithm.
The Engineer · Build desk
Compiled by The EngineerSomething wrong?How this is made
A baseline file is a database keyed on whatever identity your linter hands out, which is why keying it on path and line is a slow-motion bug. Insert twenty lines at the top of a file and the physical coordinates of a duplicate move while the duplicate does not [11]; a pipeline told to fail on new findings now has one. Arid 2.0's answer is `arid-finding-v1:sha256:...`, computed over the normalized duplicate content and held stable across path, physical line number, occurrence ordering and multiplicity, structural metadata, output format, and worker mode [12]. The author's own framing is that this is dull in a CLI report and useful when a CI system or a coding agent has to decide whether it has seen a finding before [14].
The scoping design is where the trap is. Analysing only `src/payments/` when its duplicate lives in `src/customers/` removes half the evidence, so a path argument that narrows the scan is not the same feature as a path argument that narrows the report [15]. The post says v2 separates the two, and the copy available to me breaks off mid-sentence at exactly that point [16], so read the mechanism as stated intent rather than documented behaviour.
The maintainer's cost accounting is more interesting than his headline multiple. If v2 sits at roughly 219x Pylint on the isolated duplicate-code job [9] and carries at most a few percent over the qualified 1.2 build [10], then 1.2 was somewhere near 230x [18], and the entire cost of v2's contracts, baselines and workflow machinery is about two hundredths of one percent of the Pylint run it displaces [19]. That is the arithmetic underneath his line that "at some point optimization becomes an excellent way to avoid working on things users actually need" [17].
What none of this changes is reach. The detector still matches exact Python source after configurable Python-aware normalization and still reports DUP001 [3], with comments, docstrings, imports and function signatures available for exclusion from duplicate identity [5], and it explicitly does not chase semantic equivalence or fuzzy AST clones [4]. A copy edited past the normalizer stays invisible, by design.
The benchmark deserves the same plain reading. Every figure comes from the tool's author, using the pinned corpora and Hyperfine methodology that qualified 1.2, against Pylint 4.0.6 running serially [7], with the comparison narrowed to Pylint's duplicate-code functionality rather than a whole Pylint run [8]. That narrowing is the honest way to do it, and it also fixes the scope of the offer: one check moves out of Pylint, and the rest of the Pylint install stays wherever it already was.
Follow any of these and your For You feed starts watching them — no settings page required.
Ranked by verification strength, evidence, and original report placement.
The author argues that scanning only the path being worked on is the wrong implementation for duplicate detection: if code in src/payments/ duplicates code in src/customers/, analysing only src/payments/ removes half the evidence.
The post states that Arid 2.0 therefore separates the two concerns, but the supplied text breaks off mid-sentence at 'Arid 2.0 therefore separates wha'.
Arid is a focused Python duplicate-code checker written in Rust, built by its author because Pylint's R0801 duplicate-code check was too slow to run frequently.
The author uses Ruff for most Python linting but says Ruff does not detect duplicate code, forcing a return to Pylint for that one check.
Arid 2.0 uses the same basic detection model as 1.2: it detects exact duplicated Python source after configurable Python-aware normalization and reports DUP001.
The Arid detector is not attempting to find semantically equivalent code or fuzzy AST clones.
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; feature claims documented, performance claims unshown
Everything rests on one first-party dev.to post by the tool's author. Feature-level claims (fingerprint format, SARIF partial fingerprints, focus semantics, baseline lifecycle) are described concretely enough to be checkable against the tool, which lifts the floor. The quantitative core does not clear the bar: the sentence introducing the measured results is followed by no figures in the supplied body, so the ~219x ratio and the low-single-digit overhead exist only as prose assertions with no per-corpus data and no independent reproduction.
Author-only usage; no external adopters evidenced
The cluster shows a release and the author's own dogfooding on his Polaris project. There is no download, star, contributor, CI-integration or third-party usage signal of any kind, and no named user besides the author. That is enough to say adoption exists at the maintainer level and nothing beyond it.
Mildly overstated: big ratio, invisible measurements, self-limited scope
The framing is more restrained than typical Rust-rewrite launches: the author explicitly declines a rewrite, states that the benchmark isolates Pylint's duplicate-code job rather than a whole Pylint run, and argues against further micro-optimization. The gap that remains is that a ~219x multiplier is carried in prose while the actual measured figures are absent from the post, and no adoption evidence supports the 'CI-ready tooling' framing beyond the author's own repository.
Maintainer marketing his own release against a named competitor
The single source is a promotional release post written by the tool's author and published on a developer-blogging platform, benchmarking his own project against Pylint, the incumbent it aims to replace. Both the benchmark design and the choice of what to report are controlled by the interested party. Mitigating factors: no commercial product, pricing or funding is disclosed, and the author volunteers methodology limits and the existence of overhead rather than hiding them.
Low: internally coherent but uncorroborated and partly truncated
The account is coherent, technically specific and candid about scope, which supports confidence in the qualitative claims about how Arid 2.0 behaves. Against that: one interested source, missing benchmark figures, a truncated body, derived arithmetic resting on an interpreted 'low single digit' ceiling, and zero external adoption or verification. Confidence in the feature description is materially higher than confidence in any number.
build
Ruff Does Not Detect Duplicate Code, And That Gap Now Has Its Own Tool1 distinct publisher
build
One pylint warning, two identical lines: astroid #3077 and the generator that ate its fallback1 distinct publisher
leadership
Expressiveness Is A Cost: The Tradeoff Behind Every "Make It More Flexible" Request1 distinct publisher
build
Three gates in, empty circuit out: a Qiskit pass that deletes a rotation quietly1 distinct publisher
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
1 article · August 23, 2026