betaFeedback

WorksComputer Science

Complexity concentration as a god-class and god-method detector: a pre-registered test of a scale-free outlier rule against tool definitions and human labels

Abstract

God-class and god-method detectors mark concentrated complexity with a raw-scale threshold, a constant fitted on a corpus and re-fitted when the population moves. This paper pre-registers a test of a rule with no raw-scale constant: a unit is a god unit when its complexity is a robust outlier for its own codebase, a modified z-score of 3.5 or more. On 445 repositories in ten languages, 171 of them Java, and the 492 Java repositories of MLCQ, the rule is scored against PMD's GodClass, MLCQ's reviewers and two further definitions, with signal and cutoff chosen on half the repositories and read on the rest. LLM-written code may gather its complexity differently, the case for a detector that needs no re-fitting; the first question is whether one can match the scale of existing human-written code. The verdict is inconclusive on both populations, by different arms. The rule ranks PMD's god classes from the per-file maximum of cognitive complexity at per-repository AUCs of 0.916 and 0.908. On the main run it is, at its default, non-inferior within the margin to a cutoff tuned on the same population on recovery, and flags about twice as many non-god classes; on MLCQ it flags about as many and falls short of the margin on pooled recovery. Pooled, the raw value ranks god classes better than the per-repository score, and a cutoff carried between the populations lost almost nothing: both are human-written code on one scale, so the test is of matching that scale, not of surviving a shift. The rule's extra flags are small classes, just over half holding a method at PMD's own method-level threshold; its misses are large classes whose complexity is spread over many methods. Two readers of the source did not agree on what the extra flags are. Concentration finds where the complexity is; whether that place is a god unit is a question about coupling, which a registered follow-on study takes up.

Introduction

A god class is a class that does too much. Riel named the heuristic [27], Fowler catalogued the smell as Large Class and its method-level twin as Long Method [13], and Lanza and Marinescu turned the judgement into a detection strategy, a conjunction of metric thresholds [17, 21]. Every threshold-based detector in use follows that template, and the thresholds are constants on a raw scale: a weighted method count of 47, a cyclomatic complexity of 14, a cognitive complexity of 15, fifty lines. The constants are frozen percentiles of a corpus [17, 1, 12, 26], and a constant derived from a corpus is a statement about that corpus. It has to be re-derived when the population moves, and there is evidence that it may be moving: projects that adopted an LLM coding agent showed a persistent rise in complexity [14], and on a fixed assignment LLM-generated projects gathered their complexity into fewer classes, which the threshold-based detectors missed [31]. A detector whose constant is fitted to the codebase in front of it would then be worth having, but agent-written code is not yet available at the scale a pre-registered test needs, so the first step, and this paper’s question, is whether such a detector can match the single scale of existing human-written code at all.

The alternative is a rule whose constant lives on a standardised axis. Standardise every unit by its own repository’s median and median absolute deviation and flag the units whose modified z-score is 3.5 or more, Iglewicz and Hoaglin’s rule [16]. The 3.5 is still a constant, but the scale it is applied to, the median and the MAD, is fitted on the codebase at the time of use and carries no corpus: the rule is scale-free, not constant-free. The question arose in a companion study [28], which found the amount of complexity an AI agent produced on a fixed task steady across architectures and instructions while its placement moved by factors of three to ten. Placement, not amount, was what a design decided, and that turned attention from the level of a unit’s complexity to its concentration. The claim this paper tests is that a scale-free relative outlier in a per-unit complexity measure that is not size recovers the classes and methods that tuned, absolute-threshold definitions mark, and that human reviewers mark, without a raw-scale constant.

The claim was pre-registered: the primary estimand, the decision rule and its margins, the families a signal may be chosen from, the sample seed and the bootstrap were committed and tagged before the confirmatory sample was drawn. The design is tilted against the claim: every tool oracle is itself an absolute threshold, and the competitor is a cutoff tuned on the explore half of the same population, which is the right competitor for the first step, since matching a tuned constant on its own population is the bar a scale-free rule must clear before a shifted population is worth testing. The paper has three findings.

  1. The verdict is inconclusive on both populations, by different arms. Against PMD’s GodClass on 171 Java repositories and again on MLCQ’s 492, the per-file maximum of cognitive complexity ranks god classes at per-repository AUCs of 0.916 and 0.908. On the main run the rule at its default is non-inferior to a cutoff tuned on the same population on both MCC arms, flags about twice as many non-god classes, and the false-positive arm does not resolve; on MLCQ it flags about as many as the cutoff but falls short of the margin on pooled MCC. Every point estimate is on the cutoff’s side, tuning the rule’s own constant changes neither verdict, and at method level the rule is inferior.

  1. The two populations sit on one raw scale, so the first step is well posed. Pooled, the raw value of the signal ranks god classes better than its per-repository standardised score, by a resolved difference on both populations, and a cutoff tuned on one population and carried to the other lost almost nothing. Both are code written largely by people, so the test here is of matching their scale, not of surviving a shift.

  1. The errors have a shape. The rule’s extra flags are small, mostly uncoupled classes, just over half holding a method at PMD’s own method-level threshold; its misses are large classes whose complexity is spread over many moderate methods. Against MLCQ’s reviewers no detector agrees with the Blob verdicts beyond an MCC of about 0.24, and on Long Method the relative rule has the highest point estimate of the detectors tried. A blinded reading of the extra flags by the author and by a language model did not agree on what they are, and agreed on one question only, whether the class works on other objects’ data. Whether a concentration of complexity is a god unit is a coupling question, which a follow-on study, registered before these numbers existed, takes up.

Background

Marinescu’s detection strategy is a conjunction of metric filters with thresholds [21]; Lanza and Marinescu fixed the GodClass thresholds from forty-five systems [17], DECOR expressed the Blob as a rule card over size, cohesion and association with data classes [23], and PMD implements the Lanza–Marinescu GodClass directly. Every one of these has a coupling or cohesion clause beside the complexity clause; this paper uses them as oracles for the complexity clause. That the constants are hard to justify is an old observation: thresholds have been derived from benchmarks [1], fitted distributions [12], relative positions in a corpus [26], per language [15] and per architectural role [3]. Each still ships a constant derived from systems other than the one scored, and Baxter et al. found the shape of the distributions those constants cut varying with the application [5]. The rule tested here is fitted on each repository’s own units at the time of use.

The confound that matters is size: El Emam et al. showed most object-oriented metrics confounded with class size [11], and every per-file sum is nearly collinear with the size clause of every definition. The study therefore assigns every signal to a family in advance, size (per-file sums and the method count), peak (per-file maxima) and density (per-file means) at class level, and the primary may be chosen from the peak and density families only.

MLCQ is a data set of code smell reviews by professional developers on Java open-source samples, graded without a given definition and with several reviewers per sample [18]; classifiers trained on it reach a median MCC of about 0.51 for Blob and 0.81 for Long Method [19], a reference point rather than a baseline, since the rule here never sees the labels. Learned detectors are the other route past a hand-set constant: Arcelli Fontana et al. benchmarked sixteen learners on hand-labelled smells [4], and Di Nucci et al. showed the figures fell once the benchmark’s balance and overlap were corrected [10]. A learned detector carries its corpus in its weights as a fitted threshold carries it in a constant; neither is tested here. Schumacher et al. found developers agree with one another only moderately on god classes [29]. The reviewers graded samples without the repository in view, so a human label is an absolute judgement by a reader’s own budget: external, not scale-free, and the one oracle with no numeric constant inside it.

Flagged sets are scored by the Matthews correlation coefficient [7], signals by the Mann–Whitney AUC, and intervals are percentile bootstraps that resample repositories [9]. The pre-registration follows Nosek et al. [25]: the plan was committed and tagged before the confirmatory sample existed, and everything outside it is labelled exploratory.

The claim and how it is read

The primary rule is the modified zz-score,

z(x)=0.6745(x−x~)MAD⁡,flag when z≥3.5,(1)z(x) = \frac{0.6745\left(x-\tilde{x}\right)}{\operatorname{MAD}}, \qquad\text{flag when } z \ge3.5, \tag*{(1)}

with x~\tilde{x} the median and MAD the median absolute deviation of every unit in the repository at that level, zeros included. When more than half the units tie at the median the MAD is zero and the rule falls back to the mean absolute deviation with its normal consistency constant; which scale was used is recorded, because the rule is scale-free but not shape-free. It is one of five scale-free rules the plan’s Friedman read-out compares by per-repository MCC against PMD GodClass, and it had the best mean rank on the main run, 2.42 against 2.50 for Tukey’s fence and 2.67 for a one-sided MAD, within the critical difference of 0.53 of both, and ahead of the top percentile at 3.56 and the skew-adjusted boxplot at 3.85. The skew-adjusted boxplot flags 2.1% of Java files against the modified zz’s 10.6%, a fifth as many, and ranks last: the rules that flag less recover less.

Three readings. A within-repository AUC is invariant to any monotone per-repository transform, so it is identical under the relative and the absolute view: it is evidence about the signal, never about scale-freeness. The threshold-free reading pools every repository’s units into one ranking, once on the raw value and once on the per-repository modified zz, and compares the two pooled AUCs as a paired difference. The operating-point reading compares the relative rule at its literature default with the single raw-scale cutoff that maximised the pooled MCC on the explore half, both on the confirm half. Every tool definition is itself an absolute threshold, so this comparison is tilted toward the absolute competitor: a relative win is strong evidence, a relative loss weak evidence against relative rules in general. A relative rule also cannot see what an absolute rule uses: in a repository of uniformly small classes it must still flag something and PMD marks nothing. Those false positives are reported, and the decision has an arm that sees them.

The decision rule. Pre-registered, and read as the weakest of three paired comparisons of the relative rule at its default minus the tuned absolute cutoff, each on the same confirm repositories with a 95% percentile bootstrap of 2,000 resamples over repositories: macro MCC, the mean per-repository MCC difference over the confirm repositories with at least one positive; micro MCC, the pooled MCC difference over every confirm repository carrying the definition, god-free ones included; and macro FPR, the mean per-repository false-positive-rate difference over every confirm repository, lower being better. On the MCC arms the relative rule is superior if the lower bound of the difference is above 0, non-inferior if above −m-m, inferior if the upper bound is below −m-m, and inconclusive otherwise, with m=min⁡(0.10,0.30×m = \min(0.10, 0.30 \times the explore-half macro MCC of the relative rule). On the FPR arm the rule is non-inferior if the upper bound is below +0.05, superior if below 0, inferior if the lower bound is above +0.05. A signal carries the definition only if the lower bound of the confirm macro AUC is at least 0.70, and the primary is confirmatory only on at least 20 confirm repositories with three or more positives and 40 carrying the definition. The power analysis behind these constants, from a seed-1 pilot of 522 repositories, is in the registered plan: a margin of 0.05 was not resolvable at any affordable sample, 0.10 from about sixty confirm repositories. A margin of 0.10 is about a third of the MCC levels realised here, so non-inferiority on an MCC arm is a weak bar, and the point estimates are read beside the verdict for that reason.

Study design

Sample. Repositories are drawn by a seeded, stratified sampler, a separate tool of the author’s whose only inputs are GitHub’s search index and criteria fixed before any repository is inspected: ten languages (Java, Python, JavaScript, TypeScript, Go, C, C++, C#, PHP and Rust) by three popularity tiers (above 5,000 stars, 1,000 to 5,000, 200 to 999), 170,596 repositories in the frame, shuffled under the pre-registered seed 2. A candidate is usable on size alone, at least 50 functions in at least 15 source files, decided before any detection outcome. The author’s own ecosystem is excluded. The draw overlaps the seed-1 pilot in 1 repository, runkids/skillshare, which is Go, so the plan’s re-read of the primary without the pilot’s repositories is the primary itself. Each language is drawn to 30 usable repositories and, because every composite class-level definition is Java-only, a Java supplement is drawn with the same seed to a target of 150, of which 141 were usable; with the 30 Java repositories of the main draw that gives 171 Java repositories among 445. A repository is stratified by the language GitHub indexes it under and counted by the language found dominant on measurement; 30 repositories of the main draw differ on the two, so the counts by measured language sit near 30 rather than at it. Each repository is pinned to the commit its default branch was on when drawn. Because every composite definition is Java-only, the other nine languages enter only the internal Brain Method comparison and the shape diagnostics of Section 5.1; every headline number is a Java number. The 445 rows have 430 distinct GitHub owners, so the bootstrap’s assumption of independent repositories is close to met in the main run; it is not met in the MLCQ run, where apache alone holds 50.2% of the repositories, and MLCQ’s intervals are read with that in mind.

Measurement. Every function of every source file outside test, vendored and build directories is measured with lizard [30] for cyclomatic complexity [22], lines and tokens, and by the harness’s own scanners for cognitive complexity [6], nesting, Halstead volume, maintainability burden, exit points and parameters. Class level is the file, with each measure aggregated over the file’s functions as a sum, a mean and a maximum, plus the method count; the cyclomatic sum is WMC [8]. A file is positive under a class definition when any class it holds meets it; 23% of Java files hold more than one class. The lexical estimators track PMD’s own values on every Java method at Spearman 0.95 for cyclomatic and 0.97 for cognitive, with AUCs against PMD’s own thresholds of 0.997 and above, so a weak result cannot be blamed on the estimators.

Definitions and rules. The headline definitions are PMD’s GodClass (tool, Java, class level), PMD’s NPath rule at 200 [24] (tool, Java, method level), an approximate DECOR Blob composed from CK’s counts [2] as its LargeClass and LowCohesion clauses alone, the ControllerClass and association clauses omitted (composed, Java), the study’s own Brain Method (fifty lines, cyclomatic 14 and nesting 5; internal, every language, read as internal consistency only), and the human labels of MLCQ. PMD and CK run without an auxiliary classpath; the size of that under-count is bounded in § 6. Every rule is fitted on exactly the population it scores, the whole per-level universe of the repository with zeros included. A definition scoped to Java is scored on Java units only.

Split and choices. Every usable repository is assigned to an explore or a confirm half from the sample file alone, stratified by language and tier, and the assignment is recorded in every row before the first repository is measured. The primary signal is chosen on explore among the peak and density families by the macro mean per-repository AUC over repositories with at least three positives; the absolute competitor is the single raw cutoff maximising the pooled MCC on explore; a tuned relative cut is chosen the same way as a secondary. All are read on confirm. Each secondary definition gets the same read-outs and the same paired decision, with no multiplicity correction and no power to change the primary verdict.

The MLCQ sub-study. MLCQ 1.1 holds 4,764 reviewed samples for the two smells read here, 2,334 classes for Blob and 2,430 methods for Long Method, each with one or more reviews, over 522 Java repositories at 2019 commits [18]; 499 could be measured at their labelled commit and 492 cleared the substance floor. Its reviewed units are a random draw enriched by re-review of disputed samples, so the positive rate among them is not a population base rate. Reviews are converted with a pre-registered rule, a sample is positive when a strict majority of its reviews grade the smell above none, giving 254 Blob positives among 2,334 reviewed classes and 276 Long Method positives among 2,430 reviewed methods. The human definitions are scored within the reviewed units only, a class no reviewer looked at being unknown rather than negative, while every rule is fitted on the repository’s whole Java population; because MLCQ reviewed a handful of units per repository, the plan decides the human definitions on the micro arm alone. The same run re-reads the whole main plan against PMD’s GodClass on MLCQ’s repositories, a replication on a second population. Measurement was done by the harness at a committed revision recorded in every row (f9b26ba for the main run, 7b527774 for MLCQ), with lizard 1.23.0, PMD 7.27.0 and CK 0.7.0 pinned by version and checksum.

Timeline. The plan was committed and tagged (plan-v1) at 09:20 UTC on 2026-10-18, hours before the confirmatory sample was drawn. The main run’s confirmatory analysis was written once, on 2026-10-18 22:18:48 UTC; the sample files and the analysis digest were committed together after the run, at 01:14 UTC on 2026-10-19; the MLCQ run was analysed on 2026-10-19 22:20:30 UTC. That history is the author’s own record, with no third-party timestamp: a reader can check in the published repository that the tag’s commit precedes the commit holding the sample files and the digest, and nothing more. The follow-on study mentioned in § 7 registered its plan on the morning of 2026-10-20, hours before the human-label read-out here was first computed, and its plan records what of this study it had seen.

Results

Shape, read first

At class level the chosen signal’s modified zz used the MAD scale in 89% of repositories. At method level the zero-heavy signals fall back to the mean absolute deviation far more often: cyclomatic complexity, which is 1 for more than half of all methods, used the MAD scale in only 34% of repositories. The method-level rule is therefore fitted on populations that tie at the floor, and its flag rate is a property of the tail’s shape as much as of its constant. At class level the default flags between 8.4% and 12.3% of files in the median repository of each language: no language sits apart, but a rule that admits a tenth of the population is not an outlier rule in the usual sense, and the heavy tail against a small MAD that collapses the method-level rule is present at class level too, in milder form.

The primary: PMD GodClass at class level

PMD’s GodClass was evaluated on 86 explore and 84 confirm Java repositories, which carry the definition, PMD having produced no class verdict on the one remaining confirm repository; 51 confirm repositories carry three or more god classes, where a per-repository AUC is read, and 22% of Java repositories carry none. Among the peak and density families the per-file maximum of cognitive complexity, cognitive_max, had the highest macro AUC on explore, 0.916, ahead of nloc_max at 0.893; its absolute competitor is cognitive_max ≥22\ge22. A per-file maximum is a method-level property lifted to class level: it asks whether the file holds a repository-extreme method, which is worth holding in mind when the false positives are read (§ 5.5).

Read on confirm. The signal carries the definition: macro AUC 0.916, interval [0.903, 0.928] over 51 repositories, falling to 0.624 [0.579, 0.672] within the files that already pass the WMC ≥47\ge47 clause. Much of what the signal separates is the size clause, and something is left beyond it; the peak correlates with the sum of lines at Spearman 0.70 per repository. The threshold-free comparison goes against the relative view: pooled over every confirm unit the AUC is 0.923 raw and 0.903 standardised, a paired difference of −0.020 [−0.033, −0.008], absolute ranking better.

At the operating point (Table 1) the two rules reach almost the same macro MCC and the relative rule a lower micro MCC. The table’s macro MCC averages every carrying repository with god-free ones at 0; over the 63 confirm repositories with a god class, the population of the decision’s macro arm and of Table 3, the two are 0.371 and 0.380. They get there differently: the relative rule trades precision for recall, and its extra flags are false positives, a per-repository false-positive rate of 7.9% against 3.8% and 139 flags in the 21 god-free repositories against 19. The tuned relative cut, z≥2.75z \ge2.75, buys recall with more false positives still; read against the tuned cutoff on the same three arms it is inconclusive, the verdict the default reaches, so the constant is not what the rule loses on.

Rule on cognitive_maxMacro MCC, god-free at 0 (95% CI)Micro MCCPrecisionRecallMacro FPRFP in god-free repos
default: modified z≥3.5z \ge3.50.278 [0.230, 0.329]0.3780.300.590.079139/21
tuned absolute cutoff ≥22\ge220.285 [0.229, 0.341]0.4060.440.440.03819/21
tuned modified z≥2.75z \ge2.75 (secondary)0.297 [0.248, 0.346]0.3800.270.670.102203/21

Table 1. Table 1: The primary read-out on the confirm half: the modified z-score at its literature default against the absolute cutoff tuned on explore, and the tuned relative cut as a secondary. Macro is one repository, one vote, over the 84 confirm repositories carrying the definition, god-free ones at MCC 0. “FP in god-free” is the number of flags in the 21 confirm repositories where PMD marks nothing.

Read onRuleCutMicro MCCMacro MCC, ≥1\ge1 positiveMacro FPRPrecisionRecall
main run, confirm halfrelative, modified z≥3.5z \ge3.5–0.3780.3710.0790.300.59
relative, zz tuned on this populationz≥2.75z \ge2.750.3800.3960.1020.270.67
absolute, tuned on this population220.4060.3800.0380.440.44
absolute, tuned on the MLCQ170.4210.4010.0630.370.56
MLCQ, confirm halfrelative, modified z≥3.5z \ge3.5–0.3850.3700.0870.350.56
relative, zz tuned on this populationz≥2.87z \ge2.870.3870.3710.1100.320.63
absolute, tuned on this population170.4830.3900.0800.410.69
absolute, tuned on the main run220.4760.3760.0530.470.57

Table 3. Exploratory: the absolute cutoff on cognitive_max carried between populations, and the relative cut tuned on each population, against PMD GodClass on each population’s confirm half. Macro MCC is over the repositories with at least one god class, macro FPR over every repository carrying the definition.

The decision. Table 2 and Figure 1 give the three arms. The margin is 0.10. On the macro MCC arm the paired difference is −0.009 [−0.057, +0.040] over 63 repositories: non-inferior. On the micro arm it is −0.028 [−0.068, +0.005] over 84: non-inferior. On the false-positive arm the relative rule’s per-repository false-positive rate is +0.042 higher, [+0.027, +0.056]: neither below the +0.05 margin at its upper bound nor above it at its lower, so inconclusive; the upper bound misses the margin by less than a hundredth, and the lower bound, above zero, resolves the extra false positives as real. The verdict, the weakest arm, is inconclusive. Every point estimate is on the absolute side, and non-inferiority on the MCC arms says only that the rule is not more than 0.10 worse. The effective sample and the AUC floor are met; the classpath bound is met but out of order (§ 6), so the verdict is read as confirmatory with that qualification. The signal ranks alike in every slice: the macro AUC is 0.911, 0.920 and 0.916 by popularity tier, and 0.920 and 0.904 in application and library repositories, and the rule’s macro MCC by tier is 0.297, 0.278 and 0.253.

Definition (signal)Macro MCCMicro MCCMacro FPRMarginVerdict
PMD GodClass−0.009−0.028+0.0420.100inconclusive
cognitive_max, main run[−0.057, +0.040] non-inferior[−0.068, +0.005] non-inferior[+0.027, +0.056] inconclusive
PMD NPath ≥ 200−0.256−0.331+0.0520.098inferior
cc, main run[−0.308, −0.204] inferior[−0.380, −0.284] inferior[+0.047, +0.057] inconclusive
DECOR Blob (approx.)−0.023−0.032−0.0330.072non-inferior
cognitive_max, main run[−0.055, +0.006] non-inferior[−0.063, +0.001] non-inferior[−0.058, −0.011] superior
Brain Method (internal)−0.322−0.172+0.0870.066inferior
cognitive, main run[−0.355, −0.290] inferior[−0.292, −0.095] inferior[+0.078, +0.096] inferior
PMD GodClass−0.020−0.098+0.0070.100inconclusive
cognitive_max, MLCQ repositories[−0.039, −0.003] non-inferior[−0.151, −0.063] inconclusive[−0.005, +0.018] non-inferior
MLCQ Blob (human)−0.284−0.228−0.2710.014inferior
mi_max, MLCQ reviewed units[−0.389, −0.186] inferior{sup}†`[−0.324, −0.115] inferior[−0.321, −0.225] superior{sup}†`
MLCQ Long Method (human)−0.358−0.362+0.0320.100inferior
mi, MLCQ reviewed units[−0.473, −0.242] inferior{sup}†`[−0.492, −0.242] inferior[+0.000, +0.069] inconclusive{sup}†`

Table 2. The pre-registered decision for every definition read: the paired difference, relative rule at its default minus the absolute cutoff tuned on explore, with its 95% repository bootstrap, on each arm. The MCC margin is min⁡(0.10,0.30×explore level)\min(0.10, 0.30\times\text{explore level}); the FPR margin is +0.05. The verdict is the weakest arm among those the plan decides on; † marks an arm reported but not decided on (the human definitions decide on the micro arm alone).

Image not extracted

Figure 1. The decision arms of Table 2. On the MCC arms the margin tick sits at −m-m and a bar wholly to its right is non-inferior; on the FPR arm it sits at +0.05+0.05 and a bar wholly to its left is non-inferior.

Replication on MLCQ’s population. The same plan, read on the 492 MLCQ repositories with their own halves and PMD’s GodClass as the oracle, chooses the same signal at a macro AUC of 0.908 [0.900, 0.916] over 198 confirm repositories and reaches the same verdict, inconclusive, by a different arm: the macro MCC arm is non-inferior (−0.020 [−0.039, −0.003], within the margin though resolved below zero), the FPR arm non-inferior (+0.007 [−0.005, +0.018]), and the micro arm inconclusive (−0.098 [−0.151, −0.063]). The tuned cutoff is lower there (cognitive_max≥17\texttt{cognitive\_max} \ge17 against 22) and flags about as many files as the relative rule does, 8.0% against 8.7%, while leading it on pooled MCC by about a tenth; the pooled AUC difference (−0.045 [−0.080, −0.024]) says the same. Tuning the relative constant on MLCQ’s own explore half (z≥2.87z \ge2.87) changes nothing: inconclusive.

Secondary definitions. At method level the rule is inferior against PMD’s NPath: cyclomatic complexity ranks the positives at a macro AUC of 0.996, but with more than half of all methods at cyclomatic 1 the scale collapses to a mean deviation, 3.5 of it is a low bar, and the rule flags a twentieth of every repository’s methods at precision 0.07 (micro MCC difference −0.331 [−0.380, −0.284]). A cut tuned on the relative axis, z≥8.75z \ge8.75, closes much of the gap, so the failure is the literature constant on this shape of distribution, not the standardisation. The rule is non-inferior against the approximate DECOR Blob, whose tuned cutoff is a low cognitive_max≥12\texttt{cognitive\_max} \ge12 flagging more non-Blob files than the rule does, and inferior against the internal Brain Method for the NPath reason. On MLCQ the NPath and Brain Method verdicts replicate; the approximate DECOR Blob’s does not, where the plan’s procedure chose nloc_max\texttt{nloc\_max} on MLCQ’s explore half and the verdict is inconclusive (micro MCC difference −0.082 [−0.115, −0.052]).

Exploratory: the cutoff carried across populations

Every comparison above tunes the absolute cutoff on one population’s explore half and reads it on the same population’s confirm half, the best case for a raw-scale constant; the paper’s premise, that this tests matching one scale, holds only if the two populations share one. Table 3 reads each confirm half four ways: the relative rule at its default, the relative cut tuned on that population, the cutoff tuned on that population, and the cutoff tuned on the other population, seven years and a sampling frame away, carried across unchanged. The read-out was added after review and is exploratory.

The constant transfers intact. Tuned on the main run the cutoff is cognitive_max ≥22\ge22, on MLCQ ≥17\ge17; read on the main run, MLCQ’s cutoff does slightly better than the main run’s own (paired micro MCC difference +0.015+0.015 [−0.003-0.003, +0.034+0.034]), and read on MLCQ the main run’s cost is −0.007-0.007 [−0.020-0.020, +0.006+0.006]. Against the carried constant the relative rule is behind on the micro arm on both populations, within the margin on the macro arm (−0.030-0.030 [−0.062-0.062, +0.002+0.002] on the main run, −0.006-0.006 [−0.025-0.025, +0.011+0.011] on MLCQ), and flags more. What moves is the optimum per repository, not the pooled one: the cutoff that maximises a single confirm repository’s own MCC runs from 7 to 85 on the main run, quartiles 12, 15 and 26. The relative rule follows that spread, and following it does not recover PMD’s verdicts better than one constant for everyone, because PMD’s definition is itself one constant for everyone.

Read with care, the transfer says less than it seems to. A pooled objective that cannot tell 22 from 17 cannot tell whether the scale moved by that much either, so the transfer is weak evidence for a shared scale and no evidence of a shift; it also means the competitor in the primary was loosely identified, which if anything understates the rule’s deficit. The sharper test is the threshold-free one of Section 5.2: pooling every confirm unit, the per-repository modified z ranks god classes worse than the raw value on both populations, −0.020 [−0.033, −0.008] and −0.045 [−0.080, −0.024], both resolved. One raw axis serves every repository in both populations better than each repository’s own. The comparisons above are therefore a test of matching a single human scale, not of drift: a constant against an oracle built from the same constant cannot show the oracle’s constant moving, and neither population is agent-written.

Human labels

The planned read-out. For Blob only 9 explore repositories have three or more reviewed positives, so the effective-sample gate (20) is not met, and the plan’s procedure chose mi_max, the per-file maximum of the maintainability burden. The choice exposes a flaw in the plan: the maintainability index is bounded and logarithmic, so its upper tail is compressed; a per-repository AUC is invariant to that compression, while a modified z of 3.5 on the compressed axis is out of reach in most repositories, and the chosen rule cannot flag. The micro MCC difference is −0.228 [−0.324, −0.115]: inferior, underpowered. For Long Method the procedure chose mi on 13 repositories, the same bounded index at method level. There the rule does flag, 104 methods at recall 0.47, but the cutoff tuned on the same axis reaches recall 0.91, and the read-out is −0.362 [−0.492, −0.242], inferior and underpowered. On the two structure signals the plan did not choose, cognitive and cc, the default rule reaches a micro MCC within 0.08 of a cutoff tuned on MLCQ’s own explore half on both, 0.617 against 0.674 on cc; that is the best of 7 candidates and upward-biased. No human-label result here is confirmatory.

Tools and rules against the reviewers. The exploratory comparison asks how well each fixed definition agrees with the reviewers at all, and whether the classes the relative rule flags that PMD does not are classes people call Blob. Nothing here is tuned on MLCQ: the signal, the rule and the cutoff are the main run’s. Repositories on which the tool definition was never evaluated are dropped, which is why the unit counts in Table 4 are slightly below the number of reviews that land on a measured file.

PredictorFlaggedPrecisionRecallMCC95% CI
Blob: 390 repositories, 1,827 reviewed units, 204 reviewer positives (base rate 11.2%)
PMD GodClass2360.310.36+0.242[+0.186, +0.301]
DECOR Blob (approx.)3350.240.40+0.196[+0.142, +0.256]
WMC ≥47\ge473980.250.48+0.226[+0.171, +0.283]
relative: modified z≥3.5z \ge3.5 on cognitive_max3260.250.40+0.202[+0.153, +0.254]
absolute: cognitive_max ≥22\ge222420.290.34+0.220[+0.162, +0.284]
Long Method: 392 repositories, 1,988 reviewed units, 220 reviewer positives (base rate 11.1%)
PMD NPath ≥200\ge200280.930.12+0.312[+0.244, +0.371]
CC ≥14\ge14470.960.20+0.420[+0.353, +0.485]
cognitive ≥15\ge151020.870.40+0.565[+0.497, +0.629]
NLOC ≥50\ge50680.910.28+0.481[+0.412, +0.542]
Brain Method (internal)41.000.02+0.127[+0.060, +0.189]
relative: modified z≥3.5z \ge3.5 on cc2050.650.60+0.582[+0.517, +0.641]
absolute: cc ≥15\ge15450.980.20+0.421[+0.354, +0.485]

Table 4. Exploratory: each fixed definition and the main run’s two rules as a predictor of the reviewers’ verdict, over the reviewed units of every usable MLCQ repository, with a 95% repository bootstrap on the MCC.

On Blob every detector is weak and none is separated from the others: PMD’s GodClass reaches an MCC of +0.242 [+0.186, +0.301] against the 204 reviewer positives among 1,827 reviewed classes, the relative rule +0.202 [+0.153, +0.254], and no paired difference between the relative rule and a fixed definition is resolved. The reviewers’ Blob rate is 30.9% among the classes PMD flags, 16.9% among the 183 classes the relative rule flags and PMD does not, and 7.1% among the classes neither flags: four in five of the rule’s extra flags are not Blobs to the reviewers either. On Long Method the fixed thresholds are precise and recall little, and the relative rule on cc trades precision for recall and has the highest MCC point estimate of the detectors tried, +0.582 [+0.517, +0.641]; paired over repositories its lead is resolved over PMD’s NPath, CC≥14CC \ge14, fifty lines and the tuned cutoff, and not over cognitive ≥15\ge15 (+0.017 [−0.050, +0.085]). A reader should expect this number to shrink on replication.

Exploratory: what the false positives are

The rule’s extra flags against PMD are the cost the decision turned on. Two read-outs, both added after review, ask what they are. The first characterises every one of them by the tool definitions’ own component clauses: over the 60,363 Java class units of the 84 confirm repositories carrying PMD GodClass, Table 5 splits the units by the rule’s flag and PMD’s verdict and gives each group’s share passing PMD’s size clause (WMC ≥47\ge47), marked by a coupling component (CK’s CBO ≥14\ge14 or PMD’s CouplingBetweenObjects), marked by a cohesion component, and holding a method at cognitive complexity 15, PMD’s own method-level threshold, with the group medians.

GroupUnitsRepos.WMC ≥47\ge47CoupledLow cohesionCog. ≥15\ge15Median cognitive_maxMedian linesMedian methods
flagged by the rule and marked by PMD1,8415696.8%74.3%86.5%87.9%2941532
flagged by the rule, not marked by PMD4,2887824.1%38.5%84.1%56.3%171139
marked by PMD, not flagged by the rule1,2745091.9%66.8%91.0%26.5%1127232
neither52,960842.5%8.2%78.4%2.4%1275
flagged by the absolute cutoff, not marked by PMD1,7536440.6%45.1%83.1%100.0%3016510

Table 5. Exploratory: every Java class unit of the confirm repositories carrying PMD GodClass, grouped by the relative rule’s flag and PMD’s verdict, with the share each group’s units meet of PMD’s size clause, of the coupling and cohesion components and of PMD’s method-level cognitive threshold, and the group medians. The last row is the explore-tuned absolute cutoff’s own extra flags.

The extra flags are not god classes by size: only 24.1% of them pass the size clause against 96.8% of the classes PMD marks, a coupling component marks 38.5% against 74.3%, and the cohesion components separate nothing. What does mark them is PMD’s method-level rule: 56.3% hold a method at or above cognitive complexity 15, against 2.4% of unflagged classes. The absolute cutoff’s own extra flags are larger and more often coupled: at a raw cutoff the extra flags are big classes that missed on data access or cohesion, at a relative cut they are small classes with one complex method, in the median a file of about ten methods and, in just over half of cases, a method at PMD’s cognitive threshold in a small class.

The classes the rule misses have the opposite shape. The 1,274 god classes PMD marks and the rule does not flag have a median of 32 methods, 91.9% pass the size clause and 66.8% are coupled, but only 26.5% hold a method at cognitive 15. Their complexity is spread over many moderate methods, and a per-file maximum cannot see it: the family restriction that keeps the size confound out of the signal (§ 2) also makes it blind to the god class that is large without being anywhere steep, the cost of reading concentration as a peak rather than as a share of the repository’s total.

The second read-out reads the source. A seeded sample of 100 of the rule’s extra flags and 100 of the classes it flags that PMD also marks, at most 3 per repository, was read blind to PMD’s verdict, though not to the file’s size, under a protocol written before any file was opened: four yes-or-no questions (whether the most complex method implements one algorithm over the class’s own inputs, whether the class has one responsibility, whether it works mostly on other objects’ data, and whether its complexity is one dispatch table) and a fixed mapping from the answers to four categories, leaf, gatherer, table and other. Reading conventions that settle what the questions leave open were added after the author had read 13 units and before any model reading; they change no question or mapping row, and those 13 units were re-read under them. The author read a seeded subset of 20 extra flags and 20 of PMD’s god classes before the model read; the model, Claude Fable 5.1 through the Claude Code command line (version 2.1.307) on 2026-10-22, read all 200 in ten independent sessions of twenty files at default sampling settings, each seeing only the protocol and its batch. The protocol, every reader’s answers and the model’s recorded sessions are in the ancillary data.

Table 6 gives the reading. The two readers do not agree on what the files are: to the author 75% of the extra flags are gatherers, to the model 66% are leaves, and on the 40 units both read they agree on 21, Cohen’s κ\kappa of 0.20. Each reads the two groups more alike than apart. The disagreement sits in the responsibility question (κ\kappa 0.07), which the model answers yes for 96% of the extra flags and 82% of PMD’s god classes and the author for 30% and 5%. The one question they answer alike is whether the class works mostly on other objects’ data (κ\kappa 0.61, against 0.23 on the algorithm question and 0.22 on the dispatch table): yes for 40% of the extra flags against 70% of PMD’s god classes to the author and 16% against 22% to the model, the same direction for both, but neither difference resolved, Fisher’s exact test giving p=0.111p = 0.111 and p=0.368p = 0.368. The differences that do resolve are the model’s, on responsibility (p=0.003p = 0.003) and so on gatherers (p=0.045p = 0.045), on the question the readers answer least alike; those are two of sixteen uncorrected tests, eight per reader, and are read as exploratory. The reading establishes neither that the extra flags are leaves nor that a reader can tell them from PMD’s god classes by eye; what two readers could judge alike is the coupling question the follow-on study measures rather than reads.

ReaderGroupnnLeafGathererTableOther
authorflagged by the rule, not marked by PMD205 (25%)15 (75%)0 (0%)0 (0%)
authorflagged by the rule and marked by PMD201 (5%)19 (95%)0 (0%)0 (0%)
modelflagged by the rule, not marked by PMD10066 (66%)17 (17%)5 (5%)12 (12%)
modelflagged by the rule and marked by PMD10058 (58%)30 (30%)2 (2%)10 (10%)
agreementauthor with model: 21 of 40 units, Cohen’s κ=0.20\kappa= 0.20

Table 6. Exploratory: the blinded reading of 100 of the relative rule’s extra flags and 100 of its flags that PMD also marks, by the author on a seeded subset and by a language model on every unit, each unit’s category given by the protocol’s fixed mapping of the four answers. Leaf: one algorithm, one responsibility, own data. Gatherer: more than one responsibility, or mostly other objects’ data. Table: one dispatch table.

Deviations from the plan

The classpath validation ran after confirm was read. PMD and CK ran without an auxiliary classpath, so GodClass’s data-access clause sees only the sources. The plan bounded that under-count by building at least ten explore-half Java repositories with their own build tool and re-running PMD with the built classpath, with a bound of 10%; it was due before the confirm half was read and was run after, on explore repositories only. Of 29 candidates worked down in seeded order, 10 built. 26 of 390 verdicts flipped, 6.7%, every one a god class gained with the classpath; 23 of them are in one repository (Anuken/Mindustry, 16.3%) and over the other nine the rate is 1.2%. The bound is met. The under-count is one-sided, every flip a god class gained, but its effect on the paired comparison is not: a gained god class the rule had flagged turns a false positive into a hit, and one it had not flagged adds a miss. At 6.7% of verdicts, 1.2% outside one repository, the effect is small in either direction. Because the order was wrong the confirmatory analysis file records the primary as not confirmatory for want of the validation, and the re-analysis that applied the bound is a dated exploratory file; the two agree on every number. A reader who holds to the plan’s order may read the primary as exploratory.

The human read-out is computed by the paper’s scripts. The harness writes its definition registry before the first repository is measured, and the MLCQ run’s registry holds no human definition, so the planned human read-out is performed by this paper’s scripts with the harness’s statistics module and the plan’s constants, on the reviewed units reduced from the per-unit data. The reduction is checked against the harness’s own analysis file on the main run, where every number it reproduces agrees to nine decimals. It was first computed on 2026-10-20 and last regenerated on 2026-10-22 10:03:52 UTC with every number unchanged.

Added after review. Four read-outs were added after drafts were reviewed, none pre-registered and each labelled exploratory where it appears: the paired differences in the agreement comparison (computed 2026-10-22 10:04:06 UTC), the cross-population transfer and the tuned relative cut on the plan’s three arms (2026-10-22 16:59:08 UTC), the size correlation of the primary signal, and the characterisation and reading of the false positives (2026-10-22 22:26:23 UTC). None changes a pre-registered number.

Discussion

Not worse on recovery, at a cost. Against PMD’s GodClass the scale-free rule did not beat the tuned cutoff on any arm, and every point estimate of the primary is on the cutoff’s side; its one resolved win against a tool definition, fewer false positives against the approximate DECOR Blob, is on a secondary. Every tool oracle is a raw-scale constant, so against the tools these comparisons could at best have shown the rule matching a constant, and a loss against them is weak evidence, as § 3 said in advance. The one oracle with no constant inside it, the reviewers, is read on too few repositories to decide. The confirmatory verdict therefore answers a narrower question than the title asks: whether a relative outlier recovers PMD’s verdicts as well as a constant tuned to them. On one population it does, within the margin, and on the other it falls short on pooled recovery; whether it recovers a constant-free judgement of a god unit as well as a constant does is left open.

The steps, and which one this is. The case for a scale-free detector is that agent-written code may concentrate complexity differently from the corpora the constants were fitted on [14, 31]; in a lab setting, agents building whole applications have been seen to centralise logic into single “manager” classes [32], while on files with explicit LLM attribution in real repositories class-level metrics sit at near parity with human-written code [20], so the shift, if there is one, may be small. That case cannot be tested until populations of agent-written code exist at scale, and a detector that fails on human-written code would have nothing to offer them. This study is the first step, on human-written code. The second is the follow-on coupling study, which asks whether the false positives can be separated from the god units by what a unit does with other objects’ data. The third, which neither study makes, is to take the refined detector to agent-written code, by agent adoption as He et al. did for complexity [14] or under a fixed task as Zhang, Wen and Tempero did [31]. Nothing here measures whether the scale moves.

Method level, and the class-level rule’s flag rate. At method level most methods have the lowest possible value, the robust scale collapses to a mean deviation, and 3.5 of it is a low bar; yet on the structure signals the default rule reaches a micro MCC within 0.08 of a tuned cutoff against the reviewers’ Long Method verdicts. The constant is the problem, not the standardisation. The same diagnosis applies, in milder form, at class level, where the default admits a tenth of files. A scale-free rule needs a constant fitted to the shape of these distributions; the natural candidate is the same rule on a logarithmic axis, a modified z of log⁡(1+x)\log(1+x), which is as scale-free as the rule tested and compresses the tail that collapses the MAD. It was not run and belongs in a registered follow-on.

What warrants the next study. The rule’s extra flags are small classes with one steep method, one in six of them a Blob to MLCQ’s reviewers, more than twice the rate among unflagged classes and less than among PMD’s flags; its misses are large, coupled classes whose complexity is nowhere steep; and reading the source separated neither group from PMD’s god classes to either reader. The reading that fits is that complexity concentration locates where a codebase’s complexity has gathered, and that whether the place is a god unit is legible neither in the complexity nor, reliably, in a reader’s sense of responsibility. A leaf that holds the complexity of the algorithm it computes, a parser, a solver, a state machine, is an outlier for its repository and is where that complexity belongs. Complexity alone cannot tell it from a class that gathers responsibilities; every definition in this study that does so adds a coupling clause to do it. The follow-on study asks whether a unit’s coupling divergence, what it hands on to the rest of the system against what it receives, separates a complex leaf from a god unit among the units complexity alone flags. Its plan was registered before the human-label numbers here existed and records what of this study it had seen.

Threats to validity

Construct. Every tool definition is an absolute threshold and imperfect, so against the tools this measures agreement between detectors on terms that favour the absolute competitor. The approximate DECOR Blob keeps two of its four clauses; the Brain Method is internal; cognitive complexity, Halstead volume, the maintainability index and nesting are lexical estimators calibrated against PMD. The class-level unit is the file. The human labels are absolute judgements by readers who did not see the repository and who agreed with one another only moderately.

Internal. PMD and CK ran without a classpath; the validation bounds the effect at 6.7% of verdicts on ten repositories and was run out of order. Test code is excluded by directory conventions that can miss or over-match. The relative rules are fitted with zeros included, which makes the zero-heavy method-level signals fall back to a mean-deviation scale. The human read-out rests on 9 (Blob) and 13 (Long Method) repositories for its signal choice.

External. GitHub repositories of 200 stars or more, ten languages, one commit each, with equal allocation across tiers, so pooled numbers are not population estimates. Every composite definition is Java-only, so the recovery result is a Java, class-level result. The MLCQ population is MLCQ’s choice, half of it Apache, at 2019 commits, and its intervals overstate its independence; its reviewed units are enriched by re-review. The sampler is the author’s own tool; its draw is reproducible from the published derivation, and the published sample files, pinned to commits, are the record.

Conclusion validity. One primary, one decision rule and one read of the confirm half were fixed in advance; everything added after review is labelled exploratory, and the one favourable human-label number is a best-of-many comparison a reader should expect to shrink. The reading has two readers, one the author and the other a language model whose answers are not a human’s, who agree on the category at a κ\kappa of 0.20; the author read 40 units, the reading was blind to PMD’s verdict and not to size, and a third reader would be needed to say which reading is the better one. The model is a commercial product whose behaviour can change between releases, so its archived sessions, not a re-run, are the record.

Reproducibility and data availability

Every number in this paper is produced by a script from the harness’s output. The ancillary data holds the harness’s confirmatory analysis files and the dated exploratory re-analysis, the sample files and frozen explore/confirm assignments, the per-repository summaries and definition registries, the converted MLCQ labels, the classpath reports, the paper’s own reductions, and every reader’s answers on the false-positive sample with the model reader’s recorded sessions, with the digests as committed. The raw per-unit data regenerates by running the harness on the published sample files, and the ancillary README names the public repositories of the harness, the sampler, the companion study and the follow-on study, with the command behind every number.

Conclusion

A unit whose complexity is a robust outlier for its own codebase ranks above the classes PMD does not call god classes in nine pairs of ten, on two populations of human-written code that sit on one raw scale, and at its literature default comes within the pre-registered margin of a cutoff tuned to that scale on one population and short of it on the other, at about twice the false positives on the first. The verdict is inconclusive, and the result that carries forward is the shape of the errors. Concentration finds where the complexity is. Some of those places are god units and some are small classes doing the work they were written to do, and a complexity measure cannot tell the two apart because the difference is not in the complexity. Two readers of the source could not tell them apart by eye either, and agreed with each other on one question only, whether the class works on other objects’ data. That is a coupling question, and it warrants the next study, which measures it; the detector that study refines is the one to take to agent-written code.

Competing interests

The author created and maintains OfficeFloor, a framework whose design rests on taking data off the control flow, and the construct the follow-on study tests, coupling divergence, comes from that line of work. This study compares no frameworks and its sample excludes the author’s own ecosystem, but the reading in § 7, that the false positives call for a coupling measure, is the reading the author’s interest favours, and a reader should weigh it as such. The author was one of the two readers of the false-positive sample; that reading was blind to PMD’s verdict, made under a protocol committed before it, and is reported beside the model’s with their disagreement. The sampler and the companion study are the author’s as well. Against the interest: the plan, the seed and the decision rule were fixed before the data existed, the verdict that resulted is inconclusive rather than favourable, every deviation is reported with its effect, and a replication needs no cooperation from the author.

Funding

This work received no external funding and was carried out and paid for by the author.

References

  1. [1]T. L. Alves, C. Ypma and J. Visser, “Deriving metric thresholds from benchmark data,” in Proc. IEEE International Conference on Software Maintenance (ICSM), pp. 1–10, 2010.DOI
  2. [2]M. Aniche, “Java code metrics calculator (CK),” 2015. Version 0.7.0.
  3. [3]M. Aniche, C. Treude, A. Zaidman, A. van Deursen and M. A. Gerosa, “SATT: Tailoring code metric thresholds for different software architectures,” in Proc. 16th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM), pp. 41–50, 2016.DOI
  4. [4]F. Arcelli Fontana, M. V. Mäntylä, M. Zanoni and A. Marino, “Comparing and experimenting machine learning techniques for code smell detection,” Empirical Software Engineering, vol. 21, no. 3, pp. 1143–1191, 2016.DOI
  5. [5]G. Baxter, M. Frean, J. Noble, M. Rickerby, H. Smith, M. Visser, H. Melton and E. Tempero, “Understanding the shape of Java software,” in Proc. 21st ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pp. 397–412, 2006.
  6. [6]G. A. Campbell, “Cognitive Complexity: a new way of measuring understandability,” Sonar-Source white paper, 2018.
  7. [7]D. Chicco and G. Jurman, “The advantages of the Matthews correlation coefficient (MCC) over F1 score and accuracy in binary classification evaluation,” BMC Genomics, vol. 21, 6, 2020.DOI
  8. [8]S. R. Chidamber and C. F. Kemerer, “A Metrics Suite for Object Oriented Design,” IEEE Transactions on Software Engineering, vol. 20, no. 6, pp. 476–493, 1994.DOI
  9. [9]A. C. Davison and D. V. Hinkley, Bootstrap Methods and Their Application. Cambridge University Press, 1997.
  10. [10]D. Di Nucci, F. Palomba, D. A. Tamburri, A. Serebrenik and A. De Lucia, “Detecting code smells using machine learning techniques: Are we there yet?” in Proc. 25th IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), pp. 612–621, 2018.DOI
  11. [11]K. El Emam, S. Benlarbi, N. Goel and S. N. Rai, “The confounding effect of class size on the validity of object-oriented metrics,” IEEE Transactions on Software Engineering, vol. 27, no. 7, pp. 630–650, 2001.
  12. [12]K. A. M. Ferreira, M. A. S. Bigonha, R. S. Bigonha, L. F. O. Mendes and H. C. Almeida, “Identifying thresholds for object-oriented software metrics,” Journal of Systems and Software, vol. 85, no. 2, pp. 244–257, 2012.DOI
  13. [13]M. Fowler, Refactoring: Improving the Design of Existing Code. Addison-Wesley, 1999.
  14. [14]H. He, C. Miller, S. Agarwal, C. Kästner and B. Vasilescu, “Speed at the cost of quality: How Cursor AI increases short-term velocity and long-term complexity in open-source projects,” in Proc. 23rd International Conference on Mining Software Repositories (MSR), 2026; arXiv:2511.04427.DOI
  15. [15]S. Herbold, J. Grabowski and S. Waack, “Calculation and optimization of thresholds for sets of software metrics,” Empirical Software Engineering, vol. 16, no. 6, pp. 812–841, 2011.DOI
  16. [16]B. Iglewicz and D. C. Hoaglin, How to Detect and Handle Outliers. ASQC Quality Press, 1993.DOI
  17. [17]M. Lanza and R. Marinescu, Object-Oriented Metrics in Practice. Springer, 2006.DOI
  18. [18]L. Madeyski and T. Lewowski, “MLCQ: Industry-relevant code smell data set,” in Proc. 24th International Conference on Evaluation and Assessment in Software Engineering (EASE), pp. 342–347, 2020. Data set version 1.1, Zenodo record 3666840.
  19. [19]L. Madeyski and T. Lewowski, “Detecting code smells using industry-relevant data,” Information and Software Technology, vol. 155, 107112, 2023.DOI
  20. [20]T. Mao, D. Zhao, H. Tang, X. Wang and H. Zhang, “A large-scale comprehensive measurement of AI-generated code in real-world repositories,” arXiv:2603.27130, 2026.arxiv.org/abs/2603.27130
  21. [21]R. Marinescu, “Detection strategies: metrics-based rules for detecting design flaws,” in Proc. 20th IEEE International Conference on Software Maintenance (ICSM), pp. 350–359, 2004.DOI
  22. [22]T. J. McCabe, “A Complexity Measure,” IEEE Transactions on Software Engineering, vol. SE-2, no. 4, pp. 308–320, 1976.
  23. [23]N. Moha, Y.-G. Guéhéneuc, L. Duchien and A.-F. Le Meur, “DECOR: A Method for the Specification and Detection of Code and Design Smells,” IEEE Transactions on Software Engineering, vol. 36, no. 1, pp. 20–36, 2010.DOI
  24. [24]B. A. Nejmeh, “NPATH: a measure of execution path complexity and its applications,” Communications of the ACM, vol. 31, no. 2, pp. 188–200, 1988.DOI
  25. [25]B. A. Nosek, C. R. Ebersole, A. C. DeHaven and D. T. Mellor, “The preregistration revolution,” Proceedings of the National Academy of Sciences, vol. 115, no. 11, pp. 2600–2606, 2018.
  26. [26]P. Oliveira, M. T. Valente and F. P. Lima, “Extracting relative thresholds for source code metrics,” in Proc. IEEE Conference on Software Maintenance, Reengineering and Reverse Engineering (CSMR-WCRE), pp. 254–263, 2014.DOI
  27. [27]A. J. Riel, Object-Oriented Design Heuristics. Addison-Wesley, 1996.
  28. [28]D. Sagenschneider, “Conserved amount, negotiable placement. Prompting perturbbs one architecture, an AI reviewer both,” 2026. https://doi.org/10.5281/zenodo.23190619
  29. [29]J. Schumacher, N. Zazworka, F. Shull, C. Seaman and M. Shaw, “Building empirical support for automated code smell detection,” in Proc. ACM-IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM), article 8, 2010.DOI
  30. [30]T. Yin, “Lizard: a simple code complexity analyser,” version 1.23.0.
  31. [31]Z. Zhang, E. Wen and E. Tempero, “Can LLMs produce better object-oriented designs than human-involved development?” arXiv:2605.19901, 2026.arxiv.org/abs/2605.19901
  32. [32]Y. Zhu, N. Tsantalis and P. C. Rigby, “AI-generated smells: An analysis of code and architecture in LLM- and agent-driven development,” arXiv:2605.02741, 2026.arxiv.org/abs/2605.02741

Paper details

vlnc:W_2wv9dw3s
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents