The bug is one spelling away from the fix you just shipped

Reviewed, tested, declared done — and still wrong

We ran three sweeps of our own platform on three separate occasions. Each one found real defects in code that had already been reviewed, tested and shipped.

• A safety check blocked one way of writing a dangerous command and left the more common spelling wide open.
• One model name was hard-coded, so four later releases silently stopped working while everything looked healthy.
• A release check compared version numbers and reported everything in agreement, while six packages had shipped code nobody could actually install.

None of these were found by reading harder. Each was found by asking where else the same mistake appears — which is a question you can put on a schedule.

What a routine is

Three parts. Nothing else.

The task

One sentence describing what to look for.

Guardrails

Bounds on how it may answer, including which ones must never be relaxed.

Stop when

The condition that ends the run, so it finishes rather than wandering.

No numbered procedure. Telling a model to do step one, then step two, caps the result at whatever the author imagined — and every model release makes that cap tighter. A routine says what finished means and leaves the route there to the model.

Five built-in routines

Each one comes from a defect this platform actually shipped. A routine invented from first principles reports work that does not exist, so every one names the incident behind it.

• Adjacent spelling

  The near-variant a fix missed — the same bug, one spelling away.

• Stale instructions

  Guidance in your project that the code now contradicts.

• Abstraction police

  Logic copied across modules where the copies have already drifted apart.

• Dead code

  Exported functions, files and settings that nothing reaches.

• Coverage drift

  Tests so weak they would still pass if the behaviour were deleted.

A check you run is a claim. A check we verify is evidence.

Anyone can run a sweep and write down what it found. That note is your own account of it — which is the one thing an auditor cannot accept, because nothing in it proves you did not simply write what you wanted.

Enterprise Skills adds the part you cannot produce for yourself: a fingerprint of your code tied to the exact commit that was reviewed, countersigned and stored where it does not depend on trusting your machine. That is what answers "prove this review happened" months later, to someone with no reason to take your word for it.

Anyone can run a check. Not everyone can prove they did.

What each plan gets

Designed, not yet built

The following are specified and on the roadmap. They are not available in any plan today, and the CLI says so rather than offering an upgrade that buys nothing.

• Attested records — a result verified and stored independently of the machine that produced it.
• Organisation-wide history, and share links an auditor can open without a licence.
• A routine result that can block a merge, and routines that run across every repository at once.

Try it

With a Pro licence:

enterprise-skills routine list
enterprise-skills routine show adjacent-spelling
enterprise-skills routine schedule adjacent-spelling

The first one to run is the adjacent-spelling sweep. It finds the most of anything we ship.