Proof-Carrying Work: Demonstrating Human Mastery in an AI-Assisted World
A proposal for making human and AI contributions visible through provenance, reproducible work, and demonstrated understanding.
Engineering Systems
Mechanism-first technical writing about architecture, reliability, languages, and engineering judgment.
14 posts
One Core, Many Languages: Three Ways to Share Code on the Same Machine
An exploration of same-node code sharing across languages through three boundaries (in-process gRPC over protobuf, WebAssembly modules, and FFI), why WebAssembly is the most versatile, and how platform and performance decide which one you use.
Swift's Actor Model vs Rust's Ownership: Why Rust Doesn't Need Actors
A Swift admirer's deep dive into why the actor model feels like it stops short of full isolation, why Rust reaches data-race freedom without any actors at all, and why adding strict, safe concurrency to a mature language is a monumental engineering pursuit worth praising.
Shift Left Until the PR Is Just a Confirmation
Agentic tooling made pull requests cheap and plentiful, so the bottleneck moved from writing code to trusting it. The answer is not another review loop but front-loaded rigor: invest the engineering effort ahead of time to build a full, production-shaped synthetic environment you run locally, so that validation itself becomes cheap and the PR turns into a context-sharing mechanism instead of an approval gate. Tools like .NET Aspire and Dapr show what that inner loop can look like, and the same principles carry over to homegrown systems.
The Bicycle of the Mind: Fast, Slow, and Automatic Thinking About Agents
Kahneman's two modes of thinking (fast System 1 and slow System 2) map onto learning to ride a bicycle. Attention gives way to automaticity, and that same arc is a methodology for thinking about agents, leverage, and engineering systems.
Blameless Engineering: No Heroes, Just Systems
Blameless engineering, borrowed from Google's SRE culture, is usually filed under postmortems. But the postmortem is only the last place the culture shows up. Blamelessness shifts all the way left into how you design systems, and it lands on one uncomfortable rule: the team is the unit of work, and heroes are a symptom of a system that is not yet well crafted. In the age of agents, where there is no one to blame, that rule stops being a nicety and becomes the only way to debug at all.
A Case Against Using the Word 'Bad' in Engineering
I used to say bad version, bad rollout, bad payload. I stopped, because a version isn't good or bad in the abstract. It's a distribution of outcomes across a population of users, configs, and use cases. The same payload can be flawless for 99% and broken for 0.5%, and calling it bad collapses that spectrum onto one label that quietly dictates how you triage, communicate, and remember the incident.
Fearless Engineering
When I was starting out, hesitation held me back from trying things. Over time it faded, not because I got braver, but because I got a better handle on risk. Fearless engineering is not the absence of caution. It is a calculated read of what you know, what you do not, and how far a change can reach.
Orthogonal, Not Opposite
Salty is not the opposite of sweet. They are separate receptors, separate dials, and salted caramel exists because you can turn up both at once. Most 'balance' advice is secretly slider-thinking. The method is to catch the false opposite, test for a real tradeoff, and go to the corner everyone told you was impossible.
10,000 Hours Was Never Enough
Time matters, but expertise does not come from time alone. In software engineering, AI makes the missing part impossible to ignore: growth comes from new constraints, real feedback, rising stakes, and ownership of outcomes.
Context as Code
Configuration earned its place next to code: versioned, reviewed, owned. The corpus of context that aligns a team (design docs, contextual documents, the why behind the system) deserves the same standard. It's the operating system humans run on, and now the grounding agents read to understand how we work.
Minimize Humans as Glue
Tanya Reilly's 'Being Glue' names the invisible human work that holds a team together but never shows up on your own record. The deeper pattern is the same one behind every high-maintenance system: a person standing in for a fix that was never made. The goal is not to be better glue, it is to build systems that heal themselves so humans are needed as glue as rarely as possible.
Context Hunting vs Context Gathering
Why the word 'hunting' matters: context doesn't just lie around waiting to be picked up. Real context requires active investigation, tracing code, chasing state transitions, and turning what you found into something the whole team can use.
Leverage and the Stairs You Build
Archimedes asked for a long enough lever to move the world. Engineering is the discipline of building those levers (correctly sized stairs, daily practice, scaffolded learning, and iterative cycles) so any wall becomes climbable.