Portfolio
Zack
Forward-Deployed Engineering portfolio
The short version
You have a stack of résumés and, likely, someone in-house in mind. What neither can show you is here: five systems, built end to end, running for real people — a painting contractor, a nonprofit club, a coffee guide — each built to prove what it claims rather than ask for trust. I sit with the person who owns the problem, build inside the tools they already use, and hand over something they can check and keep.
Software that asks to be trusted eventually gets something wrong quietly. Everything here is built the other way: it proves itself, and when it can’t, it says so out loud.
Capabilities
Vaults that can prove they haven't rotted
Every long-running project keeps one file that is supposed to be the truth, and every one of them rots. I build source-of-truth vaults that carry their own verifier: each section is hashed, so a match proves that section unchanged — and a separate consistency proof against a manifest held elsewhere catches the harder case, an edit to a past entry that re-stamps itself clean.
Agent roles that survive long sessions
Setting an agent's role in the prompt works for ten minutes and fails at hour four. I build the role into the folder structure instead, so it comes from the contract file a stage loads rather than from anything the agent was told — with a routing table naming what a session may not load, and outputs that sit in a pending folder until a human moves them. The gate is folders, not flags, because a boolean can be set by the code that wants it set and a folder cannot move itself.
Rails that refuse instead of reporting
Written rules are an honor system, and I have the receipts: one audited session skipped a mandatory pre-flight every single time, then repeated two prohibitions it could quote back verbatim. So I stopped writing detectors and started writing code that runs before a tool call commits and can refuse it. In that same audit, the instruction was skipped completely and the gate that blocks was skipped zero times.
Wiring a new project in one command
Hand-wiring projects into shared standards produced half-wired projects and a registry nobody could trust. One command now births a project connected both ways: it pulls the shared rules by citation at session start, and its own records ride a daily patrol back. Wire-time proof rather than wire-time hope — every file pattern it registers is resolved against the real filesystem, and the spawn exits non-zero if one matches nothing.
Where this bites in a business
Two things a business is under pressure to do at once: adopt AI, and ship faster than it can carefully review. Both ask for trust on faith, and faith is where the quiet, expensive failures live — a stale paragraph acted on as current, a policy everyone can quote and nobody follows, a role that dissolves at hour four of a long session. The four capabilities above are one answer applied four ways: don’t ask to be trusted, prove it, and fail loudly when the proof isn’t there. A system that can prove its own claims is a system a stakeholder can bet on.