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 statecrafting org; the front door is statecraft.ing. 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.

statecraft: the same ideas at platform scale; the governed agentic delivery control plane. Tenants, a factory that stamps applications from a versioned template contract, a fleet plane that operates them on Hetzner k3s, and a governance UI over it all; every substantive change is bound to the spec that authorised it, and a PR-time coupling gate keeps that binding honest. AGPL-3.0. It is itself the first production EnRaHiTu app, so the platform is governed by the same machinery it offers. 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:

• 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 embedded store at the heart of every EnRaHiTu app.

• 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."