Architecture Is a Step, Not a Seat

A Tuesday last month. I was handed a feature to design, the kind of work that used to open with a week of alignment and close with a document. By the evening it was in staging. Schema, migration, endpoint, screen, tests. I built all of it myself.

The design document never existed as a document. I made every decision in it. Nobody needed to read them, because the person who needed them was me, eleven minutes later.

The speed is not the interesting part. The missing artifact is.

The title paid for a handoff

Software architect became a job because building was expensive.

When a feature took a quarter and six people, somebody had to decide its shape before all those hands could move at once without colliding. The decision had to leave one head and arrive intact in several others. So the decision became a document. A diagram. A review gate. A room where everyone nodded at a boundary drawn on a whiteboard, then went away for three sprints.

All of that machinery existed to carry a decision across a gap, and the gap was the cost of implementation.

I spent years getting good at the carrying. Writing the kind of document that survives contact with six engineers and two deadlines. Drawing the boundary tight enough to be useful and loose enough to build inside. Sitting in the meeting where the boundary gets argued with. Real skill, and valuable, because the gap was wide.

The gap closed. I decide a boundary at ten in the morning and the thing exists by four in the afternoon, built by me and a handful of agents working in parallel. One person reaches platform scale now. Writing code stopped being the slow part of the work, and the slow part was what my title was organized around.

The decision moved. It did not vanish

I still decide where the boundary goes. What owns the write. What the contract looks like. What happens when the third-party call times out at the worst moment, in a regulated domain where wrong code has consequences.

Every one of those decisions happened on that Tuesday. They happened minutes before the code instead of weeks before it, by the person writing the code instead of across a handoff, and none of them became an artifact for anyone else.

That is a step. Like writing a test, like choosing a name, like reading a stack trace. Everyone building takes it now, several times a day, usually without calling it anything.

A step does not need a seat, and it does not need a title.

The step is still expensive

The hard part of the work was never the diagram.

It was choosing the boundary I will still like in two years, after the product changes twice and a compliance rule I have not read yet arrives. An agent holds no opinion about this. It builds the wrong contract as fast as the right one, with better formatting and a cleaner commit message. Ask for a service and you get a service, including the version where changing one business rule needs three deploys and a migration.

Taste under constraint did not get cheaper. Nothing absorbed it.

So the work is safe and the seat is not, and those are two separate sentences. I keep watching people defend the first one when somebody attacks the second.

Models ship versions. Careers ship habits

Look at the ladder of what the tools took.

Autocomplete finished my line. Then a function. Then a whole file with tests. Now a feature, end to end, in an afternoon.

Each release quietly removed a slice of somebody's job description, and nobody was asked to vote. The model did nothing to deserve the improvement. It arrives finished, the way it arrives finished every few months, with a changelog and a price per million tokens.

No version ships for me. There is no October release of Elber with improved judgment and a wider grasp of the business. Whatever I am better at this year, I chose, on purpose, in hours I could have spent on something easier.

That asymmetry is the part people miss. The tool improves while you watch it. You improve only when you move. Reading the release notes of a model feels like keeping up, and it is consumption.

What I actually changed

Four habits, in order of how much they cost me.

I stopped writing documents for humans to implement and started writing specs machines execute. Same rigor, different reader, and the reader never skims.

I stopped reviewing diffs line by line. Output is uniform now and reading it tells me less than it did three years ago. I review the system that produced it instead. The rules, the pipeline, the gates, the tests I trust.

I stopped grading myself on whether the design was right. The thing is live in a day, so correctness is observable. Does it hold in production, under real load, with real data, at two in the morning.

I started guarding what does not get built harder than I ever guarded a boundary. When building is cheap, refusal is the scarce decision.

None of this makes me an architect. Some days it makes me a developer with unusually strong opinions and four terminals open.

A title describes what was expensive when somebody wrote it. Mine was written when moving a decision between people was the slowest thing in the building. The price changed. I would rather notice that myself than have it explained to me in a reorg.