Agents are taking the typing. The part of the craft I love is getting more of my time than ever.
A little while back I wrote that attention is the new bottleneck in agentic development: agents made execution cheap, and human judgment and energy are what’s left as the constraint. I stand by that. However, it was the wrong post to start with, because it listed the costs and never said what they were paying for.
This is what I should have led with: I’m having more fun building software right now than at any point in my career.
I Could Turn a Knob On a Graph.
My first program ran on a TI-83 Plus Silver Edition, in ninth grade (no affiliate link). I wanted a more intuitive understanding of how the constants in a trig function changed its shape. The way to do that by hand was to edit one coefficient, re-graph, and try to remember what the last curve had looked like. So I wrote something that took the constants as inputs and drew the curve for me. Then I could feed it new values and watch the wave grow, stretch, and slide.
I have no memory of what the code looked like. What I do remember is seeing the graph move, and realizing that if you solve a problem in the abstract, you no longer have to think about the pedantic details.
Saving the manual computation was nice. The bigger thing was that once the function lived in the abstract, I could ask about the whole family of curves instead of one at a time, and build an intuition I couldn’t get plotting by hand. I love that feeling, and it’s been one of the core motivators in my career.
Coding Is Not Typing.
I love the craft of coding: domain modeling, designing abstractions, deciding what the pieces are and where the seams go so the next change is just another boring detail. Typing was a necessary part of the process. There was no better way to translate the design into code.
I’ve spent a lot of my career trying to design code so I can safely forget about the pedantic details. A type system enforces the domain model so invalid states won’t compile. A factory makes the valid object the easiest one to construct. A strategy pattern turns a new variant into one more file instead of one more branch in every caller. Each one does what the TI-83 program did: it pushes the fiddly parts down so I can work on the part I care about.
Embracing agentic development is the same idea aimed at a much wider target. I still design the code. I decide how the domain should be modeled, what the API contracts are, and how the database is structured, and the agent works out the details and types them in. While I work on the shape of the system, the layer below me does the work. Nobody would mistake that for vibe coding.
The Fun Part Is Now Where the Time Goes.
I used to spend most of my day on implementation. The design of a feature was settled in the first hour or two, and the rest of the day went to typing it out. Then I’d spend time fixing the places where I’d typed it wrong and dealing with environment issues. The fun part was a small slice of my day.
Now that first hour is the bulk of the work: where the boundaries go, how to shape the abstractions, which of two designs better handles the change we already know is coming. This is the collaborative, energizing work often done by a team together at a whiteboard. For me, this is the fun work.
A recent example: a specialized report builder over Power BI datasets. I spent a couple of days on nothing but design: the domain object model, the API surface, the database tables, the JSON shape of a saved query. Then, working with an agent, every invariant was written down as the name of an integration test that would hold it. From there the agent built it test-first, and by the next day it was a fully functional thirty-thousand-line full-stack web application. In the old world that would have been the same couple of days of the fun thought work, followed by weeks of typing.
The Craft Is Alive.
The version of this I keep hearing is that agents are taking the craft away. Ask which part of the craft you mean. If you mean the typing, then yes, most of that is going or gone. The part I mean is the design of the code, and that’s getting more focus than it ever has before.
The drain I wrote about is still real. Steering several streams of work at once is more tiring than writing one function well, and I haven’t settled how to spend that attention. But if you’re two weeks in and exhausted, that isn’t a verdict on the approach.
So find the part of the craft that brings you joy, and give it more of your time. Start at the whiteboard instead of the editor. Model the domain, design the abstractions, and let the layer below work out the rest. For me, the craft is alive and well.