Millwright

Formerly Daedalus — the project was renamed to Millwright in July 2026; old links redirect.

Millwright is a spec-driven development kit for AI agents in Claude Code that verifies its own work: fresh-eyes verification, tests on every edit, a council for irreversible decisions, and human gates where they matter. It implements the Millwright Method — a lightweight standard for developing software with AI agents (kit/METHOD.md).

The kit is the product. The kit is content, not software: a constitution, skills, agents, hooks, and templates for Claude Code. The millwright CLI/TUI is the vehicle that installs, checks, and updates that content — it does not run the agents itself. Claude Code is the runtime; the kit is what it runs.

IDEA ──► SPEC ──► DESIGN ──► PLAN ──► EXECUTE (per ticket) ──► SHIP
/brief   /spec   /council    /plan    /ticket · /epic

The four commands

The kit is embedded in the binary, so every command works offline. Each takes an optional target directory (default: the current directory).

Command	What it does	One-line example
init	Instantiate the kit into a repo's .claude/ and development/ (non-destructive; skips files already present)	millwright init --yes --name Acme --description "A sample app" --stack "Go 1.23 + Charm" --build-cmd "make build" --test-cmd "make test" --lint-cmd "make lint"
status	Render a read-only work map from the ticket frontmatter and STATE.md	millwright status
doctor	Check an installed kit's integrity and version against the binary	millwright doctor
update	Bring an installed kit up to the binary's embedded version, backing up replaced files	millwright update --dry-run

Run millwright init with no flags in an interactive terminal to fill the same values through a form. Run millwright with no arguments to launch the welcome TUI; in a pipe or CI it prints a short notice and exits cleanly. Print the version with millwright --version.

Install

The install script downloads the right prebuilt binary for your platform from GitHub Releases, verifies its checksum, and puts millwright on your PATH:

# Linux and macOS
curl -fsSL https://raw.githubusercontent.com/Codigo-de-Altura/Millwright/main/scripts/install.sh | sh

# Windows (PowerShell)
irm https://raw.githubusercontent.com/Codigo-de-Altura/Millwright/main/scripts/install.ps1 | iex

See the installation guide for pinning a version, choosing an install directory, manual downloads, and building from source.

Requirements

• Go 1.23 or newer (matches the go directive in go.mod) — only to build from source.
• Optional: make, Docker, and Docker Compose for the containerized dev workflow.

Build and run

go build -o millwright ./cmd/millwright   # or: make build
./millwright --version                    # or: make run

The build produces a single self-contained executable named millwright with the kit embedded inside it.

Configuration

Environment variable	Values	Default	Purpose
MILLWRIGHT_LOG_LEVEL	debug, info, warn, error	warn	Minimum log level; info/debug are opt-in.
MILLWRIGHT_LOG_FORMAT	text, json	text	Log rendering: human console (text) or structured JSON.

By default Millwright stays quiet: command output is human-readable and only warnings and errors surface. Logs are written to stderr, so they never interfere with the interface on stdout.

Project layout

kit/                 The Millwright kit — content Claude Code runs (embedded in the binary)
  METHOD.md          The Millwright Method — the versioned standard this kit implements
  constitution/      CLAUDE.md.tmpl — the behavioral constitution installed as the repo's CLAUDE.md
  skills/            /brief /spec /council /plan /ticket /epic /status
  agents/            analyst, planner, researcher, implementer(+lite), verifier, documenter, council-member, synthesizer
  hooks/             post-edit checks and session re-anchoring (sh + ps1)
  templates/         brief, spec, ticket contract, DECISION, STATE
cmd/millwright/      Binary entry point (package main)
kitembed.go          go:embed of kit/ into the binary
internal/            Core packages (not importable outside this module)
  initcmd/           `millwright init`
  statuscmd/         `millwright status`
  doctorcmd/         `millwright doctor`
  updatecmd/         `millwright update`
  kit/               Kit install/update engine (non-destructive, deterministic writes)
  tui/               Bubble Tea welcome shell (Charm)
  buildinfo/         Static binary identification (name, version)
  logging/           Structured logging baseline (log/slog)
scripts/             Install scripts (install.sh, install.ps1) for prebuilt binaries
docs/                User manual (index + chapters)
web/                 Marketing + docs website (Vite + React SPA) for GitHub Pages
development/          Method planning artifacts (v2 plan, benchmark) — not shipped in the binary

Documentation

• kit/METHOD.md — the Millwright Method: lifecycle, roles, the document contract, councils, manual gates, and token economy.
• kit/README.md — how the kit is laid out and how to edit it.
• docs/ — the user manual (installation and command usage).

License

MIT — use it, adapt it, ship it. If the Method serves your team, that's the point.