Code pipeline

Skill lankyjo/lankyjo-core-skills/skills/code/code-pipeline

My curated set of core Claude Code skills — gathered, not authored. Full credit to every original author. Install: npx skills add lankyjo/lankyjo-core-skills

Install

npx -y skills add lankyjo/lankyjo-core-skills --skill code-pipeline

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

2 things to look at

no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
0 stars0 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Mandatory post-write quality gate for every block of code written or changed. Chains code-review → simplify → verify → security-review so no code is called "done" until it is reviewed, simplified, run, and security-gated. Use whenever writing, editing, refactoring, or fixing code — automatically, not only when asked. (TDD is enforced separately, BEFORE you write code, by the /tdd pre-write gate — it is not a stage here.)

SKILL.md

3.1 KB, as published. Nobody here has run it

Code Pipeline

Every block of code I write or change runs this gated pipeline in order after the code is written. No stage is skipped to call code "done". Each stage is an existing skill — invoke it via the Skill tool (don't perform the stage inline yourself; the real skill must run).

TDD comes first — and is separate

Test-first development is not a stage of this pipeline. It happens before you write any source code, enforced by the tdd-gate.sh PreToolUse hook: a non-test source edit is blocked until the real /tdd skill has run this turn (write the failing test first). So by the time you reach this pipeline, the tests already exist. This skill is the post-write half of the loop.

The pipeline

#	Stage	Skill	Purpose
1	Correctness	`code-review`	Review the diff for real bugs.
2	Cleanup	`simplify`	Cut duplication, dead code, and needless complexity. Quality only.
3	Run	`verify`	Actually run it — tests/app/behaviour — and confirm it works.
4	Gate	`security-review`	Final gate. No "done" until this passes. Use `audit` for larger scopes.

Flow: code-review (correctness) → simplify (cleanup) → verify (it runs) → security-review (gate before done).

How to run it

Announce it at the start: "Running code-pipeline: code-review → simplify → verify → security-review."
Invoke each stage with the Skill tool, in order. Finish a stage before starting the next. Do NOT approximate a stage by hand — invoke the real skill.
If a stage surfaces a problem, fix it and re-run that stage before advancing. A failing verify or a security-review finding blocks "done".
Only after stage 4 passes, report the change as complete — and say which stages ran.

Scaling to the change

The full pipeline is the default. Scale honestly, and say what you skipped:

Logic / features / fixes → all four stages, every time.
Pure mechanical edits (rename, formatting, comment, config value, doc) → run code-review + verify and state that simplify was N/A. (These edits also take the tdd-skip escape on the pre-write gate.)
Never skip verify or security-review for anything that ships behaviour.

Honest limits

This skill is a strong instruction, backed by hooks. The PreToolUse tdd-gate.sh blocks source edits until /tdd runs; the Stop code-pipeline-gate.sh refuses to end a turn that touched source without /code-pipeline having been invoked. The gates check that the skills were invoked, not the substance — so invoking them and actually doing the work are on you. When in doubt, run the pipeline.