Short, often, plain english
The Log
Short, often, in plain english. Engineering judgment, the occasional strong opinion, and the life around it.
Log entries
16:20
Still the Painter
Engineers, illustrators, designers, session musicians. Same thread, same fear, same leap. Volume is free, therefore I am worthless. That only follows if the volume was what made you valuable, and it never was.
ai00:01
You Can't Parallelize a Certificate
At 11:18:54 on a Wednesday night I merged the pull request that moved one of my products onto its real domain. At 11:19:38 I reverted it. Forty-four seconds live. Nothing was wrong with the code. The certificate just didn't exist yet, and no amount of capacity was going to make a certificate authority hurry. I can generate software faster than I ever have. What I still can't do is compress somebody else's clock.
judgment19:20
The Man Who Tells Other People's Stories
There's a man who can talk all evening and never once appear in the story he's telling. On the difference between a story told to be admired and one handed over to be used, and why the fullest old man does both: he lived it, and he aims it at you.
life08:33
The Fleet Can't Read the Customer
It's Tuesday, the board has ten cards, and the fleet can build any of them by lunch. Building stopped being the hard part. Knowing which card matters is the hard part, and the card doesn't say. That knowledge lives in a place your agents will never reach.
judgment08:12
The Grind Was the Teacher
You didn't get good by being taught. You got good by grinding through the boring, painful work nobody wanted. The fleet does that work now, faster and without complaint. So where does the next engineer's judgment come from, if the thing that used to manufacture it just got automated away?
craft08:47
The Outage That Didn't Happen
The best thing you did all quarter left no trace. No incident channel, no postmortem, no 2am page, because the failure you designed out never fired. Prevention has no postmortem, and that's exactly why it's the first work to get cut.
judgment09:14
No-Code Is a Loan
You wired the flow on Friday and it worked. Eight months later a customer tells you it stopped, and the canvas has no diff, no test, no history you can read. No-code is a loan, and the interest comes due the day the glue turns load-bearing.
architecture08:38
Don't build the same app three times
A small team, and the plan is to staff three: an iOS engineer, an Android engineer, a web engineer. Three codebases, three release trains, the same login screen written three times and drifting apart by the second sprint. Or one React Native codebase that ships all three, one team, a bug fixed once. At GigSmart we took two apps from zero in eight months on exactly that bet. The tax is real: when a screen has to feel genuinely native, you drop down and build that piece native. So pay for polish where the product earns it, and bank the shared velocity everywhere else.
08:12
The Rewrite Looks Free Now
There's a file everyone on the team is scared of. Eight hundred lines, conditionals nobody remembers the reason for, a comment that just says don't touch this or checkout breaks. The fleet will rewrite it clean in a minute, and for the first time you can actually say yes, because the thing that always stopped you was the weeks of typing, and the typing is free now. That was never the real cost. The ugliness in that file is scar tissue, and the fleet regenerates the code without the scars.
judgment08:34
Your API is your agents' hands
Build the open API first, dogfood it, then invite others in. That used to be a pure growth bet: every team that integrates makes the product bigger than you could grow it alone. There's a second payoff now. The surface you built for outside developers is the same one your agent fleet drives. At Phoneware I put MCP servers over the platforms underneath so the fleet operates them like any other client. Design it once, for humans and agents both. Skip that and you're writing a second interface for the machines later.
08:30
Scale Is a Design, Not a Dial
You added instances and the system got slower. That's not a bug in the autoscaler. It's a ceiling that was drawn months earlier, on a whiteboard, by whoever decided where the state lives. Scale is a design decision made before a line is written, and no console reaches back to unmake it. In the agent era it's the most expensive decision of the invisible kind, because the bottleneck never shows up in the diff.
architecture08:34
Fourth of July weekend, and I was actually off. Phone in a drawer, kids outside, something on the grill. The fleet kept opening MRs, the merge train held the line, nobody paged me. I spent a lot of years being the load-bearing wall. Turns out the quiet reward for building the tracks right is that the thing stands up fine while you're not holding it up.
07:55
The Story of Ownership
You got an offer with the word 'owner' in it, and you never read the four pages after it. The vesting, the cliff, the ninety-day window where you buy what you earned or forfeit it. Ownership is the cheapest thing a company can hand out, because the word costs nothing. There's the story of ownership and there's ownership, and most places are very good at giving you the first while the second stays exactly where it was.
ownership08:30
Ownership Theater
"Act like an owner" is one of the most common asks in tech, and one of the most dishonest. It wants the behavior of ownership from people who were handed the story of it. Here's the gap, and how I build the real thing instead.
ownership08:40
Own the model
Point a task at a frontier API and you've made two decisions: rent the intelligence, hand your data to someone else's server. Sometimes that's right. Often you reached for the biggest model because it was there, not because the job needed it. Classification, extraction, routing don't need frontier reasoning. An open-weight model you run yourself does them cheaper and keeps the data in the building, and Qwen and DeepSeek are closing the gap fast. Save the frontier for the problems that actually earn it.
09:10
Concurrency isn't a feature you add
A real-time marketplace is a concurrency problem wearing a product costume. You can bolt fault-tolerance onto the wrong runtime, supervisors you hand-wrote and queues you babysit, or you can pick one where process isolation is the floor and not the upgrade. At GigSmart I reached for Elixir for exactly that. One slow request shouldn't take down the ones next to it, and on the BEAM it doesn't, by default. Reach for it when concurrency is the product. When it isn't, the runtime is a tax you didn't need. Earn it.
08:25
Read the Decisions, Not the Diff
Vibe coding is only dangerous if you don't question the output. But questioning was never reading every line, not even with humans. It's understanding the decisions the agent made and checking its finished design against the spec you handed it. The new trap: when a person makes that call, you can ask them in six months. When an agent makes it, the reasoning lives in a log that scrolls off. Holding the map on a system you architected but didn't implement isn't a new crisis. It's the oldest part of being a CTO.
judgment08:50
When the client owns the shape
GraphQL isn't an API style. It's a question about who owns the shape of the response. When one graph feeds many surfaces, iOS, Android, web, each asking for exactly the fields it needs, that ownership belongs with the client and the complexity pays for itself. At GigSmart, two apps and a web client hit one graph, and it was worth every bit of the schema. Point it at a single client talking to a single backend and you've bought resolvers and a caching headache to solve a problem you don't have. REST was fine. Earn it.
08:10
I Ran Your Demo
The 45-minute demo isn't an evaluation. It's a guided tour with the broken doors locked, and I know because I used to build the route. I started as a sales engineer. That's exactly why I won't take the call. You don't learn a tool from the path someone choreographed so you'd never click the wrong thing.
judgment08:25
Let the compiler review the fleet
A fleet of agents generates more code in an afternoon than your team used to review in a week. Most of it plausible, some of it confidently wrong, all of it too much to eyeball. The compiler doesn't get tired. Static types check every line the agents wrote before you read one. It's the instinct behind the languages I build on now, Crystal and Rust: pay a little up front, stop paying at 2am. In the agent era that bill just comes due faster.
09:30
The Load-Bearing Wall
Being the one who can always fix it feels like seniority. It's a bus factor of one with a green contribution graph. The most valuable thing you know is worth nothing until you can hand it off, to a teammate or a fleet.
leadership08:40
The Plan Was Never the Point
An agent will hand you a finished plan in twelve seconds: sectioned, sequenced, a risks heading and all. The trap is that planning was never about the document. It was the thinking that builds the judgment to adapt when reality hits. Outsource the planning and you keep the artifact, lose the map, and find out three weeks later when nobody can explain a decision nobody actually made.
judgment07:45
Earn It
The most senior move in an architecture review is usually the one that sounds the least impressive. Complexity isn't a cost you pay when you choose it. It's a tax you pay every day you operate it, and most systems start paying long before the workload was ever going to make them.
architecture09:20
Autonomy is infrastructure, not trust
"Ask forgiveness, not permission" is half a sentence. The other half is the rails that make forgiveness cheap: tests, CI, review, types. That's what lets me turn a team, or a fleet of agents, loose without signing off on every move. The guardrails catch what goes wrong before it ships. Pull them out and "move fast" is just "break things" with extra confidence. Build the rails first, then get out of the way.
21:00
The Tests Are Green
Passing CI is not the same as working software. The gap between 'the tests are green' and 'the feature actually works' is where the expensive bugs live, and in the agent era, it's getting wider.
reliability09:15
Teach the principle, not the patch
The hardest part of being a senior engineer isn't solving the hard problem. It's watching someone struggle toward it slower than you could, and keeping your hands in your pockets. Unblocking means pointing at the answer. Carrying means they need you again next time. At iTriage I learned the most durable thing a senior engineer ships is other engineers. The shortcut you hand them today is the context gap you own forever.
08:30
The context your agents don't have
An undocumented codebase has always been a tax on new hires. In the agent era it's a different problem. Agents don't go quiet when they hit a gap in context — they fill it. Confidently, and wrong. The architectural decision everyone knows because they were in the room? That doesn't exist to the fleet. They'll reverse it, build on top of it in ways that silently invalidate it. Write down why the system is the way it is. Not for the humans. For the context window.
08:15
Write it down. Not the what. The why.
Every decision your team made and never wrote down is a debt, payable by asking someone. Works until it doesn't: departures, six-month velocity gaps, agents that need context to not be dangerous. At Brandfolder, I knew why the zip pipeline was in Go. That knowledge survived because the people did. Decision records aren't documentation theater. They're the context a fleet can reason over, and the resilience that outlasts the team that built it.
09:30
A monorepo is a context boundary
The debate used to be tooling overhead and org preferences. Those tradeoffs are real. But there's a second argument now that flips the calculus. When a fleet of agents has to reason over a change, can they see the whole system? Split repos mean split context: a fix in service A that quietly breaks service B goes undetected because nothing is looking at both. One repo isn't a preference. It's the context boundary the whole system needs, for humans and agents both.
16:20
Release on Demand
A release schedule is what you build when you don't trust your releases. The fix isn't a longer freeze or a bigger window. It's making every green commit shippable and every miss recoverable before anyone notices.
releases08:47
Just use Postgres
Two engineers, a new project, and the architecture already has Redis, a queue, and Elasticsearch before a single user signs up. Postgres does all three. Not forever, but right now at your actual load. At Brandfolder we added Go when Ruby was genuinely hurting us on heavy IO. Not before. Earn the complexity. Wait until the first tool is actually failing you.
21:00
Volume Is Free Now. Judgment Is the Whole Game.
Eight years as the most prolific engineer at a company I helped build, and why I'm now convinced that was a failure, not an achievement. Volume got commoditized; judgment is the whole game.
leadership17:40
Drove to the office this morning, realized it was in shambles, and turned right back around to work from home. Some days the best architecture decision is the commute you don't make.
09:02
"Add AI" is not a roadmap item
Watching teams bolt a chatbot onto a product with no idea what problem it solves. AI is a tool, not a strategy. If you can't say what gets faster or cheaper or better, you're shipping a press release.
11:30
The deploy path is a product
If you can't release at any time, 24/7, Friday afternoon included, you don't have a culture problem. You have a tracks problem. Fix the rails and the courage shows up on its own.