I'm Bartek Kus, a systems architect from Edmonton, Canada. I work on the trust problem in AI-native software delivery:
AI can write the code. The unsolved problem is trusting what it wrote.
My answer is architecting intent: the human authors the contract, agents do the work, and machinery (not optimism) refuses anything that drifts from the contract. Stop reviewing output; start constraining intent.
Most of this lives under the stagecraft.ing org. Two flagships:
spec-spine: a typed, hash-verifiable authority ledger over a markdown spec corpus. Every spec declares the files, sections, and symbols it owns; a PR-time coupling gate refuses code that drifts from its owning spec. Deterministic to the byte across five platforms; Rust; Apache-2.0. Install from crates.io or npm. It governs itself: its own coupling gate runs against its own spec corpus in CI.
open-agentic-platform: the same ideas at platform scale; a governed control plane for AI-native software delivery. 222 frozen, hash-verifiable specs compile to a deterministic registry; every agent action reconciles to the spec that authorised it; every pipeline run emits a self-authenticating governance certificate an auditor can verify independently; the OWASP ASI 2026 control-to-spec mapping is one CLI invocation. AGPL-3.0. Built by one person directing a fleet of governed agents, which is rather the point.
And the rest of the stack that turns those two into a working delivery system:
| Project | What it is |
|---|---|
| factory-encore | Technology-agnostic software factory: business documents become a frozen, technology-free Build Specification, and an adapter turns that into a running app. Apache-2.0. |
| template-encore | The runnable Encore.ts + Vue 3 / PrimeVue reference baseline the factory composes from (public + staff SPAs, BFF gateway, OIDC auth). Apache-2.0. |
| tenant-emit | Emit-only CLI a produced app pins to build a signed governance-certificate.json from a finished run directory. Apache-2.0. |
| tenant-tail | Verify-only counterpart: re-checks the factory's run-side paperwork with zero trust in the producer. Offline, identity-free, read-only. Apache-2.0. |
| oap-bootstrap | One resumable CLI that forks the platform into a new GitHub org and brings its Hetzner K3s estate online. Apache-2.0. |
- rauthy (@sebadob): a Rust OpenID Connect / OAuth2 / PAM identity provider with passkey-first security; the OIDC backbone my platform issues tokens through.
- hiqlite (@sebadob): an embeddable SQLite that forms a Raft cluster for high availability and strong consistency; the storage engine behind my deployment orchestrator.
- Architecting intent over vibe coding. No human reviews every line an agent produces; pretending otherwise just moves the bottleneck back to the human. Make intent the requirement, the requirement a spec, and the spec law.
- Agentic output is hostile by default. Agents earn passage by surviving gates, not by appealing to trust.
- Humans gate contracts, not diffs. Specs, approvals, and irreversible boundaries are human territory; everything between them is enforced by machinery.
- Typed contracts beat convention. It's why my backends are Encore.ts, not Express: declarative, type-safe APIs that generate their own infrastructure, instead of middleware chains held together by discipline.
How I got here is one problem at three scales: a decade of digital identity (OIDC, SSI, DID) asking "can this person be trusted", platform engineering asking "can this system be trusted", and now governed agent delivery asking "can machine-generated change be trusted".
Rust • TypeScript • Encore.ts • React • Tauri • PostgreSQL •
Kubernetes • Helm • Terraform • OpenTelemetry • Claude Code • MCP
➡️ https://bartekus.com ➡️ LinkedIn: /in/bartekus ➡️ Twitter: @bartekus ➡️ Email: bartekus@gmail.com
"The human authors the law; the agents comply with it; the spine makes non-compliance impossible to merge."