complexity-reduction
Measure cognitive complexity and duplicate code with PMD (Java) or rust-code-analysis-cli (Rust), then reduce both by pure-move extraction, re-measuring after every step. Runs over a subsystem or over a PR diff. Use this when the user asks to simplify, refactor, clean up, or reduce the complexity of a subsystem, asks "how complex is X", asks to find duplicate code, asks to make code "beautiful", or asks for a complexity check on a diff or PR. It measures before it edits and re-measures after; it never accepts an unmeasured claim that a change helped. It reports only, unless the user passes `--refactor`. It is not `/simplify`, which reads the current diff and has no metric.
rustyrazorblade · AI review on file
Installation
Read the source and dependencies before running a command. Copying does not install or execute anything.
npx skills add rustyrazorblade/skills --skill complexity-reductionAbout this skill
name: complexity-reduction
description: >
Measure cognitive complexity and duplicate code with PMD (Java) or rust-code-analysis-cli
(Rust), then reduce both by pure-move extraction, re-measuring after every step. Runs over a
subsystem or over a PR diff. Use this when the user asks to simplify, refactor, clean up, or
reduce the complexity of a subsystem, asks "how complex is X", asks to find duplicate code, asks
to make code "beautiful", or asks for a complexity check on a diff or PR. It measures before it
edits and re-measures after; it never accepts an unmeasured claim that a change helped. It
reports only, unless the user passes --refactor. It is not /simplify, which reads the
current diff and has no metric.
Complexity reduction, measured
Reduce cognitive complexity and duplication in a subsystem or in a diff. Every claim is a number from a tool. Every edit is a pure move: behaviour identical, only the shape changes.
Cognitive complexity at or above 15 for one function marks a potential problem, in every language below. It is a threshold to report, not a rule to enforce.
1. Tools
Pick the tool by language. Never report a number you did not measure.
Java: pmd
pmd (Homebrew: brew install pmd). Two of its commands matter.
pmd check -R <skill dir>/pmd-complexity.xml --file-list <list> -f csv -r <out>.csv --no-progress
pmd cpd --minimum-tokens 45 --language java --file-list <list> --format csv
pmd-complexity.xml beside this file enables CognitiveComplexity (report level 15),
CyclomaticComplexity and NPathComplexity, and nothing else.
Rust: rust-code-analysis-cli
Install it with cargo. --locked is required: without it, v0.0.25 fails to compile, because
the dependency graph resolves two different tree-sitter versions (0.20 expected, 0.27 found).
cargo install --locked rust-code-analysis-cli
Measure, then pull out every function at or above the threshold:
rust-code-analysis-cli -m -p <path> -O json --pr > <out>.json
Scores live in a recursive spaces[] tree, at metrics.cognitive.sum. A flat filter misses
nested functions and closures, so recurse:
jq -r '
def scores($file):
(if .kind == "function" then
"\($file):\(.start_line)\t\(.name)\t\(.metrics.cognitive.sum)"
else empty end),
(.spaces[]? | scores($file));
. as $r | $r | scores($r.name)' <out>.json \
| awk -F'\t' '$3 >= 15'
-p takes a file or a directory. For a list of files, repeat the flag — -p a.rs -p b.rs.
A space-separated list after one -p fails, which is exactly the case diff mode hands you. Pass
-I '*.rs' to include and -X to exclude by glob.
There is no cpd equivalent here, so duplication in Rust is a read, not a measurement. Say so
rather than implying a tool checked it.
Reading the metric
Cognitive Complexity is the SonarSource metric. It charges for nesting depth, so a triply-nested condition costs far more than three flat ones. That is why extraction of a deeply nested region buys more than extraction of a long flat one, and it is why you always attack the deepest nesting first.
cpd finds only near-identical token runs. It cannot see a repeated decision whose branches
differ. Read for that yourself; it is usually the more valuable finding.
2. Pick the mode, then define the file set
Two modes. Ask the user which one if the request does not say.
| Mode | File set | Ends at |
|---|---|---|
| Subsystem (default) | The files a feature owns | Section 4, unless --refactor |
| Diff | The files a diff or PR changes | Section 4, unless --refactor |
The mode picks the file set. --refactor decides whether anything gets edited, and it is the
only thing that does.
Diff mode
Score whole changed files, not only the functions the diff touched. A small edit can push a neighbouring function past the threshold, and touched-only scoring hides that. Mark which findings the diff introduced and which were already there, so the author sees what they own.
git diff --name-only --diff-filter=d <base>...HEAD -- '*.java' # or '*.rs'
Use the PR's merge base as <base>, not HEAD~1: a branch of several commits is one unit of
review. --diff-filter=d drops deleted files, which no tool can measure.
Subsystem mode
Ask the user what the subsystem is if it is not obvious. Do not guess, and do not default to the diff.
In a git repo, the reliable way to find the files a feature owns:
git log --format='%H' --grep='<feature>' -i | while read -r c; do
git show --diff-filter=A --name-only --format='' "$c" -- 'src/**/*.java'
done | sort -u
Beware false positives: an unrelated old commit whose subject contains the same word. Read the commit subjects and drop the ones that do not belong.
Add the files the branch modifies. Then say plainly which files the feature owns and which are pre-existing, because that changes what is safe to touch.
3. Baseline, before any edit
Record all four. Without them you cannot prove the work helped.
- The complexity tool: total points, function count at or over threshold, and the per-file
breakdown. PMD reports all three directly; for Rust, sum
metrics.cognitive.sumyourself. - Duplication: the CPD blocks. Rust has no CPD, so record "not measured" rather than "none".
- Tests: the subsystem's tests, run on a clean build, and the passing count.
- Any performance guard the project already has, for example an allocation test that prints measured bytes. Record the numbers it prints, not just that it passed.
Read the test verdict from the runner's structured output, never from its exit code. For a
JUnit result XML, treat tests="0" as a failure: it means the class never started. For
cargo nextest, read the summary line, and treat a zero-test run the same way.
4. Report before you edit
Group the findings. For each, g
Read the complete source ↗