izie build standard

My whole build workflow, portable. One command on a new machine and any coding agent on it starts from how I actually build rather than from zero: the standing rules, the architecture, fifteen per-domain playbooks, and my own agent skills.

Version 3 turned it from a skill into a workspace. Version 3.1 adds the production-systems architecture learned from Nock, HackList, Auctor, AGON, Karwan, and ProofStream, strengthens research and Git ownership into absolute rules, and carries the newer Karwan workflow skill.

What is in it

SKILL.md is the core and is always loaded:

• The constitution. Twenty standing rules, from research-first and exact version pinning through to "plans accumulate, they are never rewritten in place", "what the build can prove decides what it may claim", and "evidence is generated, never captured".
• The three discipline rules that get written out in full at the top of every PLAN.md: human writing, evidence-led research, and clean code.
• The plan-first method, condensed.
• A router from what you are building to the playbook that covers it.
• Universal engineering patterns: deterministic core first, typed results at boundaries, validate every payload, optional-by-default env design, reconciliation over faith, cost ceilings with real switches, mock mode as load-bearing.
• Default stacks per domain, and the testing discipline.
• The bar everything has to clear.

references/ holds the playbooks:

| File | Covers | | --- | --- | | architecture.md | Plan lineage, verified ground truth, the pure core and its second consumer, compile-enforced boundaries, scaffold-and-refuse, atomic build groups, honesty as a design input, generated evidence, the deploy chain as a trust boundary | | planning.md | The full PLAN.md spine, living docs, the gitignore split, the hardening pass | | prose.md | The banned list, applied to comments, logs, UI strings, and store copy | | mobile.md | Flutter architecture, plugin seams, pinning, monetization, store release | | web2.md | Picking the deployable shape, optional-by-default env vars, serverless traps, caching and cost | | production-systems.md | SLO-led architecture, edge and protocols, resilience, concurrency, data, queues, security, deployment, observability, incidents, and cost | | services-and-bots.md | Module layering, the three loops, streams, idempotent event stores, captured fixtures | | web3.md | Contract idiom, threat-model natspec, money paths, custody, provability | | agents-and-llm.md | Code builds the commands, provider chains, structured output, budget guards, eval loops | | skills-and-mcp.md | Skill anatomy, the sweep that finds the gotchas, vendored-skill lockfiles, .mcp.json | | games.md | Rules engines, seeded generation, honest scoring, arena submissions, sim harnesses | | data-and-analytics.md | Collectors, documented scoring weights, history, track records, report surfaces | | brand-and-ui.md | The BRAND.md format, tokens, the anti-slop list, honest states, asset specs | | ship-and-operate.md | The runbook structure, the troubleshooting table, backups, disaster recovery, blast radius | | launch-gates.md | Store review, honest data declarations, hackathon discipline, mainnet |

skills/ holds the agent skills I wrote, and skills.lock.json pins the ones I did not.

Install

npx @kingizie/build-standard --all

That finds every coding agent installed in your home directory and lays the standard plus the authored skills into each one. Claude Code, Codex, OpenCode, Windsurf and the shared ~/.agents tree are all detected the same way.

npx @kingizie/build-standard --list --all    # print the plan, change nothing
npx @kingizie/build-standard                 # the standard only
npx @kingizie/build-standard --restore       # also fetch the pinned third-party skills
npx @kingizie/build-standard --project       # write AGENTS.md into a repo
npx @kingizie/build-standard ./some/path     # one explicit directory

Run --list first on a machine that already has skills on it. Nothing is written through a link, so an existing junction or symlink is reported and left alone rather than being written through into whatever it points at.

Fresh machine, whole workflow

npx @kingizie/build-standard --restore

Installs the standard, the authored skills, and then fetches every pinned third-party skill from its source repository into every detected coding agent. Needs git on PATH. It clones once per source repository rather than once per skill, and reports anything the pin no longer resolves to instead of failing the run. The runtime stored in the lock is provenance, not an install restriction.

Update an existing machine

After publishing a new version, inspect the plan and then refresh the standard and restore anything missing:

npx --yes @kingizie/build-standard@latest --list --restore
npx --yes @kingizie/build-standard@latest --restore

Use the exact release, such as @3.1.0, instead of @latest when a team or CI must reproduce one known workflow. Start a new coding-agent session after the install so its skill index reloads.

Cursor, Windsurf, and anything that reads the repo

npx @kingizie/build-standard --project

Writes AGENTS.md at the project root pointing at the installed standard, and appends rather than overwrites if one is already there.

Why the skills travel two different ways

The ten skills in skills/ are mine. Nothing else can restore them, so they are committed here.

The other 247 are vendored from 46 repositories and are pinned in skills.lock.json by repository, path, and immutable commit. They are deliberately not in the published tarball. Republishing other people's skills under my name is the wrong default, and a pin that has gone stale should be visible on restore rather than silently baked into a package.

Regenerate the lock after installing anything new:

npm run survey          # rewrite skills.lock.json from the machine
npm run survey:resolve  # pin new branch-only sources to current immutable commits
npm run survey:check    # report drift, write nothing, exit 1 if any

A lock that has drifted from the machine restores the wrong set, which is worse than no lock because it looks authoritative.

Using it without npm

Point your rules file at SKILL.md, or paste it into your project rules (.cursorrules, AGENTS.md, a system prompt). The core stands alone and the playbooks are pulled in by filename when a build matches. Or drop SKILL.md in a repo root as BUILD_STANDARD.md with references/ beside it and tell the agent to read it first.

Why publish it

Skills compound. Every build taught this file something. The RPC failover came from telt, the blast-radius runbook from arcrun, receipts-as-demo from karwan, the service-layer seam and the store gate from docscan, captured-fixture testing and the troubleshooting table from the Binance monitor, optional-by-default env design from versus, the shell allowlist from nansen-radar, the sim-harness discipline from the dev.fun arena bots, and the whole of architecture.md from sFace: the plan lineage, the ground-truth table read out of a shipped .d.ts, the prove script, the generated screenshots, and a deploy key that can run exactly one root-owned file and pass it exactly one commit sha. Nock added clock and tail-latency gates, HackList added durable API-effect contracts, Auctor and AGON added exact reconciliation, Karwan added durable spending and identity ledgers, and ProofStream added source-generated skill artifacts and release evidence.

Any agent that loads this starts from the accumulated version.

MIT licensed. Fork it, strip my brand rules, keep the engineering.