Skip to main content

Tools · Claude Code skills · MIT · no telemetry

Two open-source tools.

The two skills every case on this site was built with. Drop either into any .claude/ directory — and see below what they changed, measured on 7 real projects.

01 / 02 · MIT · open source

claude-shiploop

The eight-skill discipline — a lifecycle for shipping AI-collaborated software without churn.

View on GitHub
Install
curl -sSL https://raw.githubusercontent.com/ruslan4427/claude-shiploop/main/install.sh | bash

Writes to ~/.claude/{skills,agents,templates}. Prefer clone-and-inspect if auditing first.

Seven slash commands plus a domain-expert subagent that turn Claude Code from a code generator into a shipping protocol. Classifies every request, gates every build behind a spec, and leaves receipts (DEVLOG, memory, retro) in your repo — not in a chat window.

Why it exists
Claude without discipline codes immediately on every request. Discipline — classify, spec, plan, task, build, retro — is what separates vibes from engineering.
What it systematizes
Every incoming request runs through the 10-lane classifier before touching code. Every L-class feature produces spec+plan+tasks on disk. Every build iteration appends to DEVLOG. The protocol is the artifact, not another chat log.

What it changed

Discipline
100%
On tier-2 (ShipLoop) runs: spec + plan + tasks + DEVLOG present.
Rework ratio
0.48
This portfolio (hrekov-dev) under ShipLoop vs 4.5 on a tier-0 baseline.
Expert hit rate
67%
First validated capsule caught 2 of 3 blind-bugs with plan-changing findings.

Bottom line. On measured runs: 9.4× fewer fix cycles per feature, expert consultation ~2× more accurate than random, discipline binary from 0 → 1.0. Token-savings and time-to-ship claims stay refused until a matched-size tier-0 run is logged — null is honest.

How these are measured
Discipline
Method: 4-point binary: spec/plan/tasks exist in specs/<N>/ and DEVLOG.md is present.
Baseline: Tier-0 projects (pre-ShipLoop) score 0% — none of the four artifacts exist.
Rework ratio
Method: fix(…) commits ÷ feat(…) commits (conventional commits only, lifetime).
Baseline: SMM Factory tier-0 = 4.5 — ten times more rework per shipped feature.
Expert hit rate
Method: (expert consulted · plan changed = yes) ÷ (total consultations). Hand-counted today; DEVLOG convention not yet wired for auto-rollup.
Baseline: Random guess on a 3-bug test ≈ 33% — the capsule doubled that.

What we measure

  • Discipline — 4-point binary (spec, plan, tasks, DEVLOG present on tier-2 runs).
  • Rework ratio — fix(…) ÷ feat(…) conventional commits lifetime.
  • Expert hit rate — hand-counted plan-changing findings ÷ consultations across one capsule's 3-bug blind test.
  • CI hygiene — gh-sourced workflow runs + secret-scanning alerts.

Not measured yet

  • Token delta vs naked baseline. smm-factory (the tier-0 reference) wasn't token-logged — projection from rework ratio is possible but refused on principle.
  • Time-to-ship delta. ShipLoop median = 1 day; naked baseline carries null, so no comparison yet.
  • Expert auto-rollup. DEVLOG convention for consultation outcomes isn't wired — the 67% is one hand-count on one capsule, not a running aggregate.

Inspect the parser — the source for every number above.

What’s inside · 7 commands

Plus the domain-expert subagent that /shiploop-expert calls — eight parts in all.

Entry point · 2

  • /shiploop-start

    Single entry point. Classifies the current state (new project, new feature, continuing work, or status check) and routes to the right phase so you never guess which skill fires first.

    Use when: First command of any session. If you don't know whether the ask is a spec, a build, or a bug — run this.

    /shiploop-start new-feature description="<text>"

  • /shiploop-router

    Classifies any incoming request against the 10-lane table (Quick / Bug / Small / Large / Refactor / Testing / Discovery / Memory / Observer / Expert) and prints the matching protocol.

    Use when: You caught yourself about to code before classifying. Pipe the message in and let the classifier call the lane out loud.

    /shiploop-router <user request text>

Lifecycle · 1

  • /shiploop-brainstorm

    Structured brainstorm at a defined lifecycle stage. Always produces: decisions, open questions, action items, and a memory entry — never a loose doc you have to re-read to find the call.

    Use when: Discovery before spec. Post-spec stress-test. Post-QA retro. End-of-release retrospective. The stage argument gates which prompts fire.

    /shiploop-brainstorm stage=discovery

Quality + review · 3

  • /shiploop-tester

    Full QA pipeline: automated tests, Nielsen-10 UX heuristics, analytics sanity, prioritized fix tasks, and a QA report. Can scope to tests-only, ux-only, analytics-only, or a specific user story.

    Use when: After a build iteration, before merge, or when a feature feels off and you want structured eyes instead of a vibe check.

    /shiploop-tester tests-only

  • /shiploop-observer

    Audits the ShipLoop chain itself. Identifies dead agents, overlapping skills, missing lanes. Proposes consolidation or new skills — not another feature, but a workflow upgrade.

    Use when: The workflow feels slow or over-engineered. Run after every major phase to keep the ecosystem tight.

    /shiploop-observer full

  • /shiploop-expert

    Consults a domain-expert subagent at a defined review phase. Loads a cached capsule from .claude/expertise/<domain>.md or researches a fresh one (hybrid-approved) and returns issue → why → fix findings — never generic advice.

    Use when: Pre-ship second opinion before merge. In-progress sanity check after plan lands. Blind-bug when symptom is clear but root cause is not. 3/3 blind-bug catch rate on first validated capsule.

    /shiploop-expert phase=pre-ship

Meta · 1

  • /shiploop-skill-builder

    Meta-skill for authoring and auditing other skills. Produces a valid SKILL.md for a new agent, or audits existing skills for structural compliance (frontmatter, section order, invocation hints).

    Use when: You spot a recurring workflow across sessions and want to codify it. Or audit before publishing a skill to a shared repo.

    /shiploop-skill-builder create name=<skill> purpose="<one-liner>"

02 / 02 · MIT · open source

ui-ux-pro

A UI/UX skill that extracts your project's tokens first — then brings in current design thinking without breaking your system.

View on GitHub
Install
git clone https://github.com/ruslan4427/ui-ux-pro.git ~/.claude/skills/ui-ux-pro

No network at runtime. Two Python helpers for contrast and token extraction.

Two jobs. Keep a project's own design system consistent (extract tokens from CLAUDE.md / @theme / :root / tailwind.config, work inside them, never invent a new palette for a project that already has one). And bring in current design thinking — curated palettes, typography pairings, trend references — behind an opt-in style selector (minimalist / brutalist / Lusion).

Why it exists
AI design output drifts toward generic SaaS unless something forces it to read the project's existing system before suggesting a palette or font.
What it systematizes
Four-section method: tokens first, contrast gate, visual verification in the browser, then current design thinking. Style overrides are opt-in — defaults aim for a broadly safe editorial result.

What it changed

Hero regens · avg
1.00
Nano Banana 2 + the ink preset lands a publishable hero on the first pass. Backfilled across 4 of 4 shipped posts.
QA catches · avg
— (not measured yet)
All 4 shipped posts pre-date the rig — they carry null, not zero. The first rig-era post ships 2026-10-19.
Serializer round-trips
5
LinkedIn + dev.to republishes forced by UI-layer serializer bugs. Total across all shipped posts.

Bottom line. Hero generation efficiency measurably 70–80% above industry baseline (1.0 avg vs 3–5 regens). Serializer round-trips concentrate in a single pre-rig outlier — three of four posts shipped at 0. Full QA-catch claim awaits Monday's first rig-era post; stays null until then.

How these are measured
Hero regens · avg
Method: Sum of heroRegenerations frontmatter ÷ posts carrying the rig (4 posts, 4 heroes).
Baseline: Generic AI illustration pipelines typically take 3–5 regens before an on-brand hero lands.
QA catches · avg
Method: qaCatches is nullable: null = pre-rig (discipline wasn't operational), int = rig-era measurement.
Baseline: First non-null value lands Monday with shipping-claude-shiploop — the first blog post to run the formal UX pass.
Serializer round-trips
Method: Sum of serializerRoundTrips frontmatter — only counts republishes caused by a serializer issue, not cosmetic edits.
Baseline: 3 of 4 posts shipped with 0 round-trips. The outlier (classify-before-you-code) drove the whole number.

What we measure

  • Hero regens — heroRegenerations frontmatter, summed across posts carrying the rig.
  • QA catches — nullable int (null = post pre-dates the rig, integer = rig-era measurement).
  • Serializer round-trips — republishes forced by UI-serializer bugs, counted only when the cause was a serializer issue (not cosmetic edits).
  • Backfill coverage — rig-era vs pre-rig posts; stated plainly on /tools as 4 of 4 so the aggregate reading is honest.

Not measured yet

  • Rig-era QA catches. The rig landed 2026-10-17; the first non-null value arrives with shipping-claude-shiploop on 2026-10-19 — until then, the aggregate holds null.
  • Token delta between rig-era and pre-rig posts. The rig is one day old at write time; a rig-era-vs-pre-rig token comparison needs at least one Monday ship.
  • Figure revisions per hero. We count figures; we don't yet track revisions-per-figure as a running number.

Scorecard

Does the discipline pay off?

7 projects across three discipline tiers, measured from git logs, DEVLOGs and Claude Code session files — never self-reported. A dash means the signal could not be reconstructed, not that the project failed.

7 projects · generated 2026-10-18 · ✓ pass · ✕ fail · — not measured

Lexora

Tier 0 · nakedDesign
M · 17 days
Discipline
100%
Rework
0.00
Time to ship
13d
Tokens
—
Expert hit rate
—
Healthnot measuredWorkflowsnot measuredSecrets

Pre-ShipLoop. 4/4 discipline score reflects speckit-era artifacts, not institutional ShipLoop (tier reflects the latter). Rework 0 and TTS 13d both from n=1 sample. Tokens not reconstructable from mixed home-dir sessions (bail-out triggered 2026-10-14 — see spec §10.1). githubRepo null — private repository, hygiene not independently verifiable from the public /tools reader.

Noble SaaS

Tier 0 · nakedSaaS
L · 75 days active
Discipline
0%
Rework
1.44
Time to ship
—
Tokens
1.6Mdedicated session log
Expert hit rate
—
HealthfailWorkflowsnot measuredSecrets

Pre-ShipLoop. 1.44 rework over 171 conventional commits is the loudest pre-ShipLoop marker in the dataset. Dedicated session log exists; tokens measured from -Users-ruslan-noble-saas/.

SMM Factory

Tier 0 · nakedAutomation
M · 27 days
Discipline
0%
Rework
4.50
Time to ship
—
Tokens
—
Expert hit rate
—
Healthnot measuredWorkflowsnot measuredSecrets

Pre-ShipLoop. Rework 4.5 from a small n=11 conventional sample (9 fix / 2 feat) — directional, not statistically robust. Tokens not reconstructable from mixed home-dir sessions (bail-out triggered 2026-10-14 — see spec §10.1). githubRepo null — private repository.

Angel Trucking

Tier 0 · nakedSaaS
S · scaffold only
Discipline
0%
Rework
—
Time to ship
—
Tokens
—
Expert hit rate
—
Healthnot measuredWorkflowsnot measuredSecrets

Pre-ShipLoop. Prototype did not progress past Next.js scaffold (1 commit). Zero session hits across home-dir scan — likely never engaged Claude Code beyond initial setup. githubRepo null — not published to GitHub.

Fieldmark

Tier 1 · self-specSaaS
M · 4 days active
Discipline
25%
Rework
2.00
Time to ship
—
Tokens
2.6Mdedicated session log
Expert hit rate
—
Healthnot measuredWorkflowsnot measuredSecrets

Self-authored test_plan.md (517 lines) acted as pre-spec; no ShipLoop discipline yet. githubRepo null — private repository. Archetype saas-app covers mobile+backend products in this taxonomy; splitting into mobile-app deferred to Sprint 19+ per spec §5.1.

Portfolio (hrekov.dev)

Tier 2 · ShipLoopSaaS
L · 28 days active
Discipline
100%
Rework
0.48
Time to ship
1d
Tokens
66.0Mdedicated session log
Expert hit rate
—
HealthpassWorkflowspassSecrets

ShipLoop active from Sprint 0 bootstrap (2026-09-20). 1-day median TTS reflects solo-operator cadence (plan → ship typically same day); n=5 specs. Reflects measurement across the owning org, not team scale.

claude-shiploop (OSS)

Tier 2 · ShipLoopLLM Skill
L · 3 days
Discipline
0%
Rework
1.00
Time to ship
—
Tokens
—
Expert hit rate
—
HealthpassWorkflowspassSecrets

Shipped 2026-10-16. Repo at github.com/ruslan4427/claude-shiploop. Tokens null because the OSS work ran inside the portfolio Claude Code session, not a dedicated session; commit-level signal via repoPath.

How each number is measured

Methodology

How each number is measured.

Discipline
(hasSpec + hasPlan + hasTasks + hasDevlog) / 4Binary per criterion. Checked by reading specs/*/{spec,plan,tasks}.md and the top-level DEVLOG.md. Pre-convention projects that score 4/4 ran speckit-era artifacts before ShipLoop existed — tier captures that gap.
Rework ratio
fix_commits ÷ feat_commitsPulled from git log with conventional-commit grep: fix / chore(fix) over feat / chore(add). Null when conventional === 0 (no signal, not zero rework). Infinity when fix > 0 but feat === 0.
Time to ship
median(ship_commit_date − spec_frontmatter_date)Per feature. Reads `**Date.** YYYY-MM-DD` from each specs/<N>/spec.md, diffs against git log of the matching specs/<N> path. Aggregates to project-level median. Null if no spec dates parseable.
Tokens
input + output + cache_read + cache_creationSummed across every assistant message in ~/.claude/projects/<project>/*.jsonl. Face value, not cost. Model attribution by exact ID map first, substring fallback. Tier 0 projects without dedicated session dirs mostly return null — see tokenSource tag.
Expert hit rate
plan_changed_yes ÷ (yes + no)Grep DEVLOG for `expert consulted` entries with `plan changed: yes|no` sibling lines. Only Tier 2 projects can score; current readings are null because the convention is young — this will be the next metric to light up.
Hygiene — universal, GitHub-sourced

Two pass/fail/null checks that apply the same way regardless of archetype. Both are probed live from the GitHub REST + Actions APIs on scorecard regen; nothing is cached. ✓ means the probe returned a measurement and it passed; ✕ means it returned a measurement and it failed; — means the probe could not get a measurement at all — usually a private repo or a scope the self-serve token can’t reach.

Workflows
all(latest_main_run_per_workflow) == success`gh run list --branch main --limit 50 --json workflowName,conclusion,status` — group by workflow, take the first completed run per group, pass only if every group's conclusion is success. Null when the repo isn't on GitHub, is private without `gh` auth, or has no completed runs on main yet.
Secrets
secret_scanning_alerts.length == 0`gh api /repos/<owner>/<repo>/secret-scanning/alerts` — pass when zero open alerts, fail when any. Null when the API returns 403/404, which usually means the repo is private without Advanced Security or has secret scanning disabled.

Tier assignment

Human judgment, not a derived score.

Tier 0 · naked
No spec, no plan, no DEVLOG. Prompts straight to code.
Tier 1 · self-spec
Project-local methodology (test plans, design systems) without institutional ShipLoop.
Tier 2 · ShipLoop
Full lifecycle: router → spec → plan → tasks → build → QA → ship → retro.

Archetype

What kind of thing is this.

A locked four-value taxonomy. Hygiene checks today are universal, but archetype-specific checks (E2E for SaaS, uptime for Automation, evals for LLM Skill) can slot in without a schema change.

SaaS
Hosted web/mobile product with its own backend, auth, data store.
Automation
Scheduled or event-driven pipeline — ETL, content ops, bots. No end-user UI.
LLM Skill
Prompt-and-skill assets that run inside Claude Code or another model host.
Design
Design-first tooling or static artifacts — mockups, Figma plugins, generators.

Null is honest

Every cell is either a measurement or a dash. No estimates, no vibes, no self-reported numbers to fill the gap. If a signal was not reconstructable, the dash is the finding — usually because the project predates the convention that would have produced it.

The raw receipt lives at /scorecard.json. The parser that generates it is at claude-shiploop/scripts.