simplify-code — independently scanned and version-tracked by SaferSkills.
SaferSkills independently audited simplify-code (Agent Skill) and scored it 100/100 (green). The audit ran 55 deterministic rules across Security, Supply Chain, Maintenance, Transparency, and Community; it found 0 high-severity and 0 lower-severity findings. The full rule-by-rule trace and per-finding evidence are below. Free, methodology-open.
Findings & checks · 0 flagged
Every scanned point with the score it earned and what moved between them.
First recorded scan — no prior version to compare against.
The primary manifest — the file an agent reads to learn what this artifact does.
Code costs more to read than to write. Treat every extra layer, branch, and clever trick as a debt that future readers pay interest on. Remove it unless it earns its keep.
Simplicity is not a style preference; it is the absence of structure that does not pull its weight. Keep an abstraction only when you can name the concrete benefit it provides right now. "We might need it later" is not a benefit you have today.
| You see | You probably want |
|---|---|
| A class that forwards every call to another object | The inner object, used directly |
| A factory that only ever builds one concrete type | A plain constructor call |
| An interface with exactly one implementer | The concrete class, interface deleted |
| A "strategy" with a single strategy | An ordinary function |
| A base class extended by one subclass | The two folded together |
| An options struct holding two fields | Two positional arguments |
TODO notes — act on them or file a ticket, then deleteFlatten with guard clauses and pipeline-style collection methods.
# Tangled: four levels before any real work happens
def notify_active(payload):
if payload:
if payload.get("recipients"):
for r in payload["recipients"]:
if r.get("subscribed"):
send(r)
# Flat: bail early, then express the intent in one chain
def notify_active(payload):
recipients = (payload or {}).get("recipients") or []
for r in recipients:
if r.get("subscribed"):
send(r)# Hard to call correctly: positional soup
def register(name, email, plan, region, trial, referral, locale): ...
# One cohesive argument the caller can read at a glance
def register(signup: Signup): ...| You see | Default move |
|---|---|
| A bespoke cache for a few dozen entries | Drop it; profile before re-adding |
| Memoization wrapped around a trivial computation | Remove the wrapper |
| Lazy-loading a module that is tiny | Import it normally |
| A state machine modeling three states | A short if/match |
Work in small, reversible steps and lean on the test suite between each.
how many abstractions stand between a feature and the work it does.
was shaped this way — there may be a constraint that the shape encodes.
for everything that follows.
merge functions that always run together.
pytest -q # behavior unchanged?
ruff check . # nothing newly broken?| Situation | Why the complexity stays |
|---|---|
| A genuine hot path tuned for speed | The shape is a deliberate performance trade |
| A structure a framework or library forces on you | The constraint is external |
| An architecture the team deliberately chose | Respect the decision; ask before undoing it |
| Growth is imminent and concrete | A seam being added for known, near-term work |
When unsure, surface it instead of silently rewriting: "This layer looks heavier than the use case needs — is there a reason to keep it, or should I collapse it?"
~30 seconds. Free. No account. Every finding cites a rule and a line of evidence.