A light-weight meta-prompting, context engineering, and spec-driven development system for Claude Code, OpenCode, Antigravity CLI, Codex, Cursor, and more.

What is MSD Core

MSD Core is a context-engineering and spec-driven development framework that drives AI coding agents (Claude Code, Codex, Antigravity CLI, Cursor, and more) through a disciplined phase loop. It solves context rot — the quality degradation that accumulates as an AI fills its context window — by running all heavy research, planning, and execution work in fresh-context subagents while keeping your main session lean.

Differences from GSD

MSD Core is a hard fork of GSD (gsd-core). It contains all GSD changes up to the fork point (everything after GSD 1.14.0 shipped in MSD 2.0.0). The phase loop, workflows and .planning/ artifacts work the same way. What differs:

	GSD	MSD
Name	`/gsd-*` commands, `gsd-tools` CLI, `gsd-core` package	`/msd-*` commands, `msd-tools` CLI, `@golem15/msd-core` package
Runtimes	18 runtimes	6: Claude Code, Codex, OpenCode, Cursor, ZCode, Antigravity. The other 12 (including Kimi) were removed, together with their installer code, capabilities, hooks and docs
Distribution	npm package	Not on npm. Installed with `curl -fsSL https://msd.golem15.com \| bash`, which clones, builds and installs from git
Releases and updates	npm versions	`vX.Y.Z` git tags on `next`, with a `stable` branch pointing at the latest one. `/msd-update` and the update check read those tags and rerun the installer pinned to the chosen version. `/msd-update --next` also considers `-rc.N` tags
Hosting	GitHub, with issue and PR governance	git.golem15.com/golem15/msd-core (Gitea). PRs go against `next`, and GSD's issue and PR governance workflows were dropped

Fixes that exist only in MSD

UAT verification loops (2.0.1). In GSD, a phase whose human UAT had passed could loop forever between /gsd-execute-phase and /gsd-verify-work. A gap-closure plan, or a later phase editing a covered file, made the verification report stale. The re-run verifier could not see the UAT results and asked for human verification again, and execute-phase then rewrote *-UAT.md with every row back to [pending]. MSD fixes each link in that chain:

The verifier reads recorded UAT results as evidence (verification.uat-evidence). A row that passed on unchanged code counts as verified. Only rows whose covered implementation files changed since the UAT are requested again, each with a retest_reason.
*-UAT.md is merged, never overwritten (verification.seed-uat). Existing rows are kept byte-for-byte, and a pass is reset only with a recorded reason.
One guarded human_needed → passed transition (verification.canonicalize-uat). It applies only when the UAT rows are the only outstanding items, and it refuses a stale report.
Stale reports are re-verified in place. verify-work and progress re-run the verifier themselves instead of routing back to execute-phase. verification.status reports a stale_reason, and progress offers every executed-but-stale phase as one re-verify action.
Gap-closure UAT answers are recorded first. execute-phase writes a gap-closure checkpoint's UAT answers before it dispatches the verifier.

Staleness still fails closed: a malformed fingerprint or a real change to covered code still marks the report stale.

Other fixes:

/msd-update and the update check work. The inherited npm-based check looked for a package that was never published, so it never found an update. MSD reads git release tags instead.
Plan-phase quota recovery. /msd-plan-phase recovers safely when an agent run hits provider quota exhaustion.

See CHANGELOG.md for the full 2.0.0 entry.

How it works

Each milestone repeats the same five-step loop, one phase at a time:

Discuss — capture implementation decisions before anything is planned
Plan — research, decompose, and verify the plan fits a fresh context window
Execute — run plans in parallel waves; each executor starts with a clean 200k-token context
Verify — walk through what was built; diagnose and fix before declaring done
Ship — create the PR, archive the phase, repeat for the next one

Quickstart

MSD Core is not published to npm. Install the latest release (needs Node.js 24+, git and jq) with:

curl -fsSL https://msd.golem15.com | bash

This installs Claude Code if it is missing, clones MSD into ~/.local/share/msd-core at the stable branch (the latest tagged release), builds it and installs it globally for Claude Code. Rerun the same command, or /msd-update inside your runtime, to update. Options go after bash -s --:

curl -fsSL https://msd.golem15.com | bash -s -- --claude --codex   # several runtimes
curl -fsSL https://msd.golem15.com | bash -s -- --local            # into the current project only
curl -fsSL https://msd.golem15.com | bash -s -- --ref next         # unreleased work from next

From a checkout of this repository you can also run the installer directly:

git clone https://git.golem15.com/golem15/msd-core.git
cd msd-core && npm ci && npm run build:hooks
node bin/install.js --claude --global

For any other runtime, run node bin/install.js directly. The installer prompts for your runtime (Claude Code, OpenCode, Antigravity CLI, Codex, Cursor, and more) and whether to install globally or locally. The installer is required for cross-runtime compatibility — do not copy files from agents/ or commands/ directly.

On another runtime or without Node.js? See Install on your runtime.

Once installed, start a new project or onboard an existing repo:

/msd-new-project   # greenfield project
/msd-onboard       # existing codebase

New here? Follow Your first project for a guided walkthrough from install to first shipped phase, or Onboarding an existing codebase for brownfield setup.

Documentation

What's new in 1.7.0 → docs/whats-new-1.7.0.md

Tutorials — learning by doing:

How-to guides — task-focused recipes:

Reference — authoritative facts:

Explanation — concepts and design decisions:

Full index: docs/README.md. Other languages: 日本語 · 한국어 · Português · 简体中文.

Why it works

Most AI-coding setups fail at scale because context bloat silently degrades output quality, there is no shared memory between sessions, and nothing verifies that code actually works. MSD Core solves all three: heavy work runs in fresh subagents, structured artifacts like STATE.md and CONTEXT.md survive session boundaries, and the verify step walks through what was built and generates fix plans before a phase is declared done. See docs/explanation/context-engineering.md for the full reasoning.

Troubleshooting? See docs/how-to/recover-and-troubleshoot.md.

Community

Project	Platform
gsd-opencode	Original OpenCode port
Discord	Community support

What MSD stands for

Make Software Done. The runners-up, preserved for posterity:

Mostly Sane Development
Minimum Suffering Delivery
Merge, Ship, Disappear

License

MIT License. See LICENSE for details.

Claude Code is powerful. MSD Core makes it reliable.