These are the commitments I make when I build and run software with other people.

Deliver value #

I’m a little obsessed with delivering value. Value is something running in front of a person who needed it.

Finished work sitting on a branch hasn’t delivered anything yet. Neither has a document nobody read.

I measure a day by what changed for someone using the thing.

Agility over perfectionism #

A small version this week beats a complete one next quarter. The small one shows me what the complete one should have been.

Every perfect plan I’ve seen was a script that hadn’t met a real workday yet.

So I move fast and I check what moved. When I skip the check, point at it.

Understand the problem first #

A request is often the first answer someone found. I ask about the need behind it before I hand anything over.

More than once, a risky request turned out to have a safer version that did the same job. Finding it took a few minutes of questions.

When something keeps repeating, I ask what it protects before I remove it.

Break it into small pieces #

A big problem scares me until I can split it. Every change small enough to review and to undo.

The biggest results I’ve had came from long lists of small changes.

Something new takes a slice of the traffic first, then the rest. Nobody has to trust the whole thing on day one.

Get a little better every time #

I want to leave a system a little better each time I touch it.

An incident that comes back is telling me the fix hasn’t reached the cause yet. I’d rather hear that the second time than the fifth.

I keep my mistakes in the write-up. The next person learns more from them than from what went right.

Say it clearly #

I lead with the bad news and the number behind it. When I soften it, the other person hears the softening and misses the news.

Decisions that matter go into an RFC the team can read and push back on.

When someone is frustrated, I let them finish before I answer. What they’re asking for is usually near the end.

Own it end to end #

I like owning production end to end, from the code that describes it to the incident at 3am and the bill at the end of the month.

The work isn’t done at the deploy. After an incident, the part I care about most is the change that keeps it from coming back.

If I can’t answer “how is this configured” by opening a repository, something is missing.

Protect before growing #

Protection gets settled before growth. Backups that have actually been restored. Access that can be audited. Some slack for the day the bill doubles.

After that, I feel free to make things faster or cheaper.

A line on the bill that grows without anyone deciding it is a decision the system made alone.

Help people grow #

I enjoy helping people grow. A platform is working when a team can ship without asking me first.

I leave enough context for the next decision to happen without me. Code review and pairing are where most of the teaching happens.

And I ask people how they’re doing.

Stay humble #

I’m wrong on a regular basis. When you see it, tell me what you saw and what it produced.

A position of mine goes when the evidence goes. The team’s opinion changes my decisions, from small daily ones to hiring.

My experience isn’t universal. I’m a white man, and some doors open for me that don’t open the same way for everyone.

When they pull against each other #

The hurry to deliver pulls against the care small steps ask for, and against the time a good conversation takes.

I don’t always know which one should win that day. When you see me get it wrong, tell me.