Ship fast.
Ship correct.

Eight skills that cascade through the development lifecycle. Each one invokes the next. The chain catches what you miss.

$ /dev-start feat memory-ttl
~/wintermute
$ /dev-start feat memory-ttl Branch: feat/memory-ttl Target: v0.4.0 (from ROADMAP) Context: 2 related items found Don't hand-roll check: ✓ No existing TTL util in codebase ✓ No npm package needed — FTS5 handles it Gray area: ? TTL per-agent or global? ? Expired memories: soft-delete or hard-delete? Boundary map: produces recallWithTTL() → MemoryResult[] consumes db.memories, agentConfig.memoryTTL Ready to implement.
the flow

Each skill invokes the next

Independently invokable. Naturally cascading. You don't memorize the workflow — the skills guide you through it.

/dev-start
Branch, context, boundary map
implement
/proving-correctness gates active
/dev-check
4-stage quality chain
/dev-commit
Conventional format + discipline
/dev-finish
Docs, summaries, merge
/dev-ship
Version, tag, deploy
interruption? /dev-pause … /dev-start resumes
found a bug? /dev-bug → fix → check → commit
new project? /dev-teach scaffolds everything
the quality chain

/dev-check before every commit

Four stages. In order. Smart skip rules prevent unnecessary work — doc-only commits fly through, feature code gets the full treatment.

STAGE 1 · SUBAGENT
Correctness
Per-file proofs: why it's correct, why it's not over-engineered, why performance is acceptable. Runs in a subagent — verbose reasoning stays out of your context window.
/proving-correctness
STAGE 2 · 3 PARALLEL AGENTS
Quality
Code reuse opportunities. Quality issues (redundant state, copy-paste, leaky abstractions). Efficiency (N+1 queries, missed concurrency, hot-path bloat).
/simplify
STAGE 3
Mechanical
Build, typecheck, test. All three pass or you don't proceed. If a fix touches earlier stages, re-run from there.
build + typecheck + test
STAGE 4
Behavioral
Beyond "tests pass" — does it actually work? Call the endpoint. Run the command. One smoke check that the thing you built does the thing.
context-specific
Change typeCorrectnessQualityMechanicalBehavioral
Feature / FixRunRunRunRun
Refactorskip — tests are proofRunRunskip
Docs onlyskipskipskipskip
Tests onlyskipRunRunskip
ConfigRunskipRunRun
the skills

Before and after

Each skill replaces a bad habit with a disciplined one. Toggle to see what changes.

/dev-start
Context before code
Loads project context, searches for existing solutions, forces decisions on ambiguous choices, and maps interfaces before a single line gets written.
  • Don't hand-roll — searches codebase, deps, stdlib first
  • Gray areas — forces concrete choices before coding
  • Boundary maps — declares produces/consumes for 3+ file changes
  • Session resume — loads .continue-here.md from /dev-pause
~/project
$ git checkout -b add-ttl $ vim src/memory.ts # 45 min later... Wait, there's already a TTL helper in utils/ And the interface changed in v0.3 Should this be per-agent? Didn't think about it Types don't match what the caller expects # rewrites from scratch
~/project
$ /dev-start feat memory-ttl Context: 2 ROADMAP items, target v0.4.0 Don't hand-roll: ✓ No existing TTL util ✓ FTS5 handles it natively Gray area: TTL per-agent or global? → per-agent Soft-delete or hard? → soft-delete Boundary map: produces recallWithTTL() → MemoryResult[] consumes db.memories, agentConfig.memoryTTL Ready to implement.
/dev-check
Tests pass is not enough
Four stages catch what tests miss: correctness proofs in a subagent, code quality review, mechanical gates, then a real behavioral smoke check.
  • Subagent isolation — correctness proofs stay out of context
  • Smart skips — doc-only commits fly through
  • Behavioral check — actually runs the feature
~/project
$ npm test ✓ 991 tests pass LGTM, shipping it. # Two days later... [PROD] recall() returns 50,000 rows [PROD] query takes 14 seconds [PROD] OOM kill on agent-memory # The query had no LIMIT clause. # Tests used a 10-row fixture. # Nobody checked real-world behavior.
~/project
Quality chain: PASS Correctness (subagent): ✓ recallWithTTL — CORRECT FTS5 bounded by LIMIT, O(log n) FLAG: recall() has no default LIMIT → Fixed: added LIMIT 100 default Simplify: ✓ clean Gates: ✓ build ✓ types ✓ 991 tests Behavioral: ✓ recall with maxAge=3600 → 12 results ✓ without maxAge → capped at 100 Ready to commit.
/dev-commit
Commits that explain why
Conventional commits format with project-specific scopes. The body explains decisions, not diffs. If the message needs "and", it's two commits.
  • Pre-gate — runs /dev-check if it hasn't been run
  • Imperative mood — "add", not "added" or "adds"
  • Split signals — detects multi-concern commits
~/project
$ git commit -m "fixed stuff" $ git log --oneline -5 a3f2c1d fixed stuff b8e4a2f updates c1d9e3a wip d4f2b1c more changes and fixes and cleanup e7a3c2d misc # 3 months later: git blame → "fixed stuff" # Why was this line changed? Nobody knows.
~/project
feat(memory): add TTL-based expiration Memories older than their TTL are excluded from recall queries. FTS5 index stays intact; expiration filters at query time, not write. Decided: per-agent TTL (user preference) Decided: soft-delete with weekly sweep Scope check: ✓ One logical change ✓ 3 files changed ✓ Imperative mood ✓ Body explains WHY [feat/memory-ttl abc1234] committed
/dev-pause
Decisions are expensive. Don't make them twice.
Captures completed work, remaining tasks, decisions made, and the exact next action into a compressed handoff file. The next session starts at full speed.
  • ~500 words max — decisions, not deliberations
  • Ephemeral — consumed and deleted by /dev-start
  • Prevents re-debate — records WHY, not just WHAT
~/project — next day
$ git log --oneline -3 a3f2c1d wip memory ttl b8e4a2f wip c1d9e3a more wip Where was I? # Reads 6 files to reconstruct context # Re-debates per-agent vs global TTL # Forgets the soft-delete decision # Implements hard-delete (contradicts yesterday) # 40 minutes lost to context reconstruction
~/project — next day
$ /dev-start Found .continue-here.md — resuming Branch: feat/memory-ttl Done: recall filtering, types, tests Left: cleanup sweep job, config docs Decisions (don't re-debate): per-agent TTL (user preference) soft-delete with weekly sweep Next action: Implement scheduledCleanup() in engine/memory-engine.ts ✓ Resuming from exact stopping point
/dev-bug
Bugs don't come back
Severity classification, mandatory regression tests, systematic root-cause analysis. The test must fail first, then pass after the fix. Non-negotiable.
  • P0/P1/P2 — severity drives response urgency
  • TDD regression — test fails → fix → test passes
  • Paper trail — bugs.md, ROADMAP, Fixes: footer, CHANGELOG
~/project
Bug: sessions leak on timeout $ vim src/session.ts # "I think it's this line" # Changes the timeout handler $ npm test ✓ 991 tests pass Fixed. Shipping. # 2 weeks later... [PROD] sessions still leaking on timeout # Wrong root cause. No regression test. # Bug comes back the same way.
~/project
[P1] Session leak on timeout Logged: docs/bugs.md ✓ Branch: fix/session-leak-on-timeout Step 1: reproduce Wrote: session-timeout.test.ts ✗ FAILS — leak confirmed Step 2: root cause (/systematic-debugging) clearTimeout called on wrong handle Step 3: fix + verify ✓ PASSES — leak gone Step 4: full chain ✓ /dev-check PASS (992 tests)
/dev-finish
Work isn't done until the docs reflect reality
Fractal summaries at three tiers — commit body, CHANGELOG, build journal. Updates ROADMAP, closes bug entries, then hands off for merge.
  • Three-tier summaries — each regenerated from source, never re-compressed
  • Doc sync — ROADMAP, CHANGELOG, bugs.md updated
  • Branch completion — merge, PR, or discard via superpowers
~/project
$ git checkout main $ git merge feat/memory-ttl $ git branch -d feat/memory-ttl Done! # ROADMAP still says "planned" # CHANGELOG has no entry # No build journal for the architecture # New dev asks "why soft-delete?" # Nobody remembers. Re-debates it.
~/project
$ /dev-finish Verification: ✓ all gates pass CHANGELOG: ✓ feat: add TTL-based memory expiration ROADMAP: ✓ memory-ttl → done (v0.4.0) Journal: ✓ decisions + trade-offs recorded Branch completion options: 1. Merge locally (fast-forward) 2. Push and create PR 3. Keep branch as-is 4. Discard Merged to main. Branch deleted.
/dev-teach
One-time project setup
Scans the project for conventions, asks targeted questions, scaffolds everything the cascade depends on. Run once, work forever.
  • Auto-discovery — reads package.json, tsconfig, git log
  • Scaffolds — CLAUDE.md, ref/workflow.md, ROADMAP, CHANGELOG, docs/bugs.md
  • Language-agnostic — TypeScript, Python, Rust, Go
~/new-project
$ /dev-start feat auth-flow No CLAUDE.md found No ROADMAP.md found No CHANGELOG.md found No docs/bugs.md found No commit scopes defined No gate commands configured # Every skill degrades to generic mode # No project-specific context # Manual setup of each file, one by one
~/new-project
$ /dev-teach Scanning project... Language: TypeScript (tsconfig.json) Test: vitest (vitest.config.ts) Commits: conventional — feat, fix, chore Quick questions: Commit scopes? engine, api, config, db Deploy target? npm publish ✓ CLAUDE.md (workflow section added) ✓ ref/workflow.md (full reference) ✓ ROADMAP.md (version structure) ✓ CHANGELOG.md (Unreleased section) ✓ docs/bugs.md (empty, ready) Project ready. Start with /dev-start
/dev-ship
Release with confidence
Reviews commits since last tag, suggests appropriate version bump, updates all tracking docs, tags, and deploys. The full release in one command.
  • Semver — reviews commits to suggest patch/minor/major
  • Full checklist — gates, CHANGELOG, version, tag, journal, deploy
  • Post-deploy verify — checks the release actually works
~/project
$ npm version patch $ git push --tags $ npm publish # Forgot to update CHANGELOG # ROADMAP still says v0.3.x # Should have been minor, not patch # Build journal? What build journal? # Didn't verify the publish worked npm info: v0.3.4 has no CHANGELOG entry
~/project
$ /dev-ship Since v0.3.3: 2 feat, 1 fix → minor bump Suggested: v0.4.0 ✓ Gates pass ✓ CHANGELOG updated (2 Added, 1 Fixed) ✓ Version bumped to 0.4.0 ✓ ROADMAP marked complete ✓ Tag v0.4.0 created ✓ Build journal entry written ✓ npm publish succeeded ✓ Post-deploy verify: OK
integrations

Composes with existing skills

The cascade orchestrates — it never duplicates. Each integration adds project-specific context and sequencing.

During implementation

  • /proving-correctnesspushback + inline checkpoints
  • superpowers:tddtests alongside features
  • superpowers:debuggingroot cause for bugs

Quality chain

  • /proving-correctnessGate 3 in subagent
  • /simplify3 parallel reviews
  • superpowers:verifyevidence before claims

Complex work

  • superpowers:brainstormideation for 8+ files
  • superpowers:plansimplementation plans

Branch completion

  • superpowers:finishmerge/PR workflow
  • superpowers:worktreesisolated workspaces

"LLMs write plausible code, not correct code. Code that compiles and passes tests can still be 20,000x slower than it should be."

/proving-correctness
get started

Two paths to install

Claude Code — prerequisites
# Install superpowers (required — cascade composes with it) claude install github:coda-oa/superpowers # superpowers provides: brainstorming, writing-plans, TDD, # systematic-debugging, verification, branch completion
Claude Code — install skills
# Clone the repo and copy skills into Claude's skill directory git clone https://github.com/smillunchick/dev-cascade.git /tmp/dev-cascade cp -r /tmp/dev-cascade/skills/* ~/.claude/skills/ rm -rf /tmp/dev-cascade # Then run once in any project to scaffold /dev-teach
Cursor / Windsurf / Aider / Any LLM Agent
# Copy agents.md into your project — self-contained, no dependencies curl -sL https://raw.githubusercontent.com/smillunchick/dev-cascade/master/agents.md \ -o .cursorrules # or .windsurfrules, AGENTS.md, system prompt, etc.
Then just work
/dev-start feat memory-ttl # begin # ... implement ... /dev-check # validate /dev-commit # commit /dev-finish # merge /dev-ship 0.4.0 # release
standing on shoulders

Built on great ideas

Superpowers
The agent skill system that makes Claude Code programmable. Dev Cascade orchestrates superpowers for brainstorming, planning, TDD, debugging, verification, and branch completion.
Impeccable
The cascading skill pattern — independently invokable skills that naturally chain to each other. Dev Cascade borrows this architecture for its eight-skill workflow.
GSD 2.0
A multi-session AI coding framework (via Lenny Rachitsky). Fractal summaries, boundary maps, continue-here files, context window management, and "don't hand-roll."