How this was made

Fast, AI-built code is not yet a product.

Software built quickly ships fast but unchecked. It forgets its own context between sessions. It skips the unglamorous parts: the docs, the mobile pass, the instrumentation, the pre-launch check. Every gap bites once real users arrive.

• The gaps are predictable, and so are the disciplines that close them.

Software delivery integrity, as skills.

Foundry makes five promises between an idea and its release. A Claude Code skill keeps each one, and you can run them yourself: product intent is declared and audited (frame), execution context survives every session (phase-plan), the outcome is instrumented (instrumentation), the documentation matches reality (document), and technical readiness is audited before real users reach it (foundry + production-audit). Delivery integrity, not product strategy. It is the outer loop: the gate at the end of the build cycle. It composes with the inner-loop skills you use to write and review code, rather than replacing them.

Documentation engineered as the agent's memory.

The failure nothing else addresses is context loss between sessions. The doc set is built so a cold start cannot go wrong. Each fact has one owner. A forever spec holds the present-tense truth. The plan chain is never empty and never padded with a filler plan: when there is honestly no next unit, the index says so.

• phase-plan writes the next unit's plan while the context is warm. A scaffolded CLAUDE.md rule makes the next session read it before acting.
• document keeps the docs and the code from disagreeing, and flags a suspected regression rather than documenting a bug.

Build and ship it, honestly.

scaffold starts a project in the shape its profile requires, not a blank prototype. document keeps the docs true to the code. It also renders the repo's own docs inside the product, so they cannot drift. phase-plan writes the next unit's plan before you close the current one.

The gates your launch needs, resolved and then enforced.

There is no universal gate list: a CLI is not a web product. foundry resolves the project's release policy (what it is, its risk tier, its audience), then scores every gate that policy names. mobile pressure-tests the real device experience where one exists. instrumentation wires the activation funnel on one identity model. A gate with no surface is marked not-applicable, with a reason. Skipping one silently is never allowed.

• A phone-breaking core flow blocks a launch.
• A product you cannot measure is not ready to ship, unless you deliberately chose to waive measuring it.

The flagship audits the whole application.

production-audit audits the whole application across eleven dimensions, applicability resolved per project, plus the release gates, and it refutes its own findings. It separates risks, the findings with a path to harm, from improvements, the ones that are safe today and make the app more robust over time, so a clean app reads as clean with a punch list, not a body count. Then it ends in one plain decision that names the evidence it rests on: a static-only run says runtime was not exercised, never overclaiming a runtime-verified result.

• Only risks decide the verdict; improvements are the punch list, not blockers. You set the scope and accept risks on the record. The severity rubric and the meaning of the verdict are fixed on purpose. A check you could always grade green is the false comfort this replaces.

Skills that resist being ignored.

A named skill is invoked and followed, never hand-reproduced. Every skill opens with a mandatory gate that makes the expected process explicit and harder to bypass. Gates improve compliance; the invariants that must hold are enforced by schema and make validate, not by prose alone.

Install once, invoke anywhere.

npx skills@latest add horizon-foundry/foundry adds the suite to your Claude Code skills (or clone and make install from source). Then run a skill by name: scaffold a project, document it, or gate a release with production-audit. When a project is nearing release, foundry check reports which pre-ship gates are met, and foundry prepare closes the gaps.