Standard Template Construct
Your coding agent's rules, memory, skills, hooks, and tools — authored once in a harness-neutral form, then deployed into any concrete harness. Edit in one place; drift becomes impossible by construction.
In Warhammer 40k lore, an STC is a relic that emits complete, reproducible blueprints adapted to the materials at hand. This project borrows the idea for your agent's configuration.
Why
STC rests on three pillars. Two are engines — a single source of knowledge and an encoded software lifecycle; both cut what the agent has to spend. The third, a lean token economy, is the result they add up to — reinforced by a few dedicated savings of its own.
Knowledge lets the agent look a fact up instead of re-deriving it — fewer tokens spent searching. The SDLC keeps every change specced, tested and reviewed on the way in, docs in one place — so maintenance and edits never spiral. The token economy is what both add up to — plus a few dedicated mechanics of its own; and as a bonus, the work itself comes out faster and more coherent.
Local-first markdown memory with [[wiki-links]] and link-integrity checking. The agent stops re-deriving hard-won project knowledge every session — and the same knowledge travels across model providers unchanged.
→ fewer search & derivation tokens
A Plan → Do → Verify loop, spec & task generators, a TDD skill, and a fresh-context three-agent review (correctness + security + QA) feeding a self-improving defect ledger. Changes ship small, tested and documented.
→ less rework, cheaper maintenance
The result of the first two — plus hygiene mechanics: raw output routed to files, expensive jobs offloaded to sub-agents, web search isolated in one research agent, each task on the cheapest capable model.
→ less waste, faster sessions
How it works
You write capabilities once, in a harness-neutral form, in core/. Adapters declare how each harness realises them. A Python deploy pipeline renders the result into the concrete harness directory — adapted to its format.
# write once, in harness-neutral form STC/ ├── core/ # universal blueprints — rules, memory, skills, hooks, commands ├── user/ # your private config — profile, project notes, secrets ├── adapters/ # per-harness descriptors — how core/ maps onto a target └── deploy/ # the pipeline — render · apply · check · restore # then reproduce it into the harness you use $ python deploy/deploy.py apply --target claude
Two axes stay orthogonal: the harness (Claude Code, others) and the provider (the model behind it). The same blueprints deploy behind a Claude model today and a different model tomorrow, with no rewrite. The model is an engine you swap; the know-how is the same.
What's inside
Who it's for
Anyone driving an AI coding agent daily who wants it to stop forgetting, stop burning tokens, and follow a real lifecycle instead of vibes.
One source of truth for rules, memory, skills and hooks across a codebase and across model providers — no per-machine drift, no vendor lock-in.
The same pipeline powers our managed Audit and Refactor offerings below — STC is both the open tool and the product engine.
Open core + services
The engine is open source — install it from the public repository and run it yourself. On top of it we're building two managed, Claude-powered services that point the same review-and-refactor pipeline at your codebase.
The full engine, AGPL-3.0. Self-install from the public repo and deploy it to your harness.
Point STC's fresh-context review pipeline — correctness, security, architecture — at any repository and get a ranked, verified findings report.
Automated, reviewed refactoring: deepen modules, cut coupling, raise testability — every change specced and verified before it lands.
The flywheel. Every audit enriches a shared library of checks, abuse-cases and defect patterns. The more repositories run through it, the more the pipeline catches — the product gets sharper with use.
Principles
Minimal third-party tools. Maximal use of the harness's own capabilities — native hooks, native imports, native sub-agents. No runtime daemon, no database, no framework.
One source of truth, many realisations. A capability is written once; each adapter declares how a harness realises it. You never edit the live harness directory by hand.
Non-destructive by construction. Collision-proof suffixes, namespaced JSON merges that refuse on genuine conflict, a backup before every write.
Degrade gracefully. A harness that lacks a native form keeps the capability — only the form is absent, never the know-how.