Zoom Out First

For years, the craft was the component. Write the cleanest hook. Handle the edge case nobody else thought of. Ship a feature so well-built that the PR itself felt like the product.

I lived this. Countless hours developing and maintaining Maker UI — my own OSS library filled with opinionated primitives that seemed perfectly tuned to every use case I ran into.

That was the job. And to be honest, it was great. Nothing felt better than mastering keyboard focus for a dialog. Or building the carousel that had every prop you might ever need for a client website or application.

Now an agent can draft that component in seconds. Often well. Sometimes better than my first pass.

Watching that happen still does something to me. Not threat exactly; closer to grief, with a quiet pride underneath.

The implementation isn't the bottleneck anymore, and that changes what good engineering actually means.

What the work became

The valuable work moved upstream. Not typing — thinking. Why are we building this? How does this deliverable connect to where the product is going six months from now? What should this iteration push toward, not just what should it ship today?

The best engineers I know aren't the fastest typists with the cleanest syntax. They're the ones who can hold complex systems in their head while deciding what to build next.

The dance

Working with agents is a partnership that runs on trust and verification. You trust enough to let go of the keystrokes. You verify enough to catch drift before it compounds.

Code review used to be a gate before merge. Now it is the work — reading what came back, asking whether it fits the architecture, pushing each iteration further than the last. Planning mode isn't overhead. It's the job. Ask mode isn't a fallback for when you're stuck. It's where the real decisions get made.

The quality of the build depends on the quality of the context you share — what you include, what you leave out, what you make explicit about the system the agent is walking into. Share too little and it guesses. Share too much and it drowns. That calibration is a skill now.

The primitives look different too. They aren't components in a repo anymore — they're skills, the latest specs, the core dependencies and documentation your agents inherit on every run. That layer evolves constantly. Keeping it current is the new version of maintaining a library.

The counterintuitive part

The engineers who feel behind aren't the ones who can't write code fast anymore. They're the ones still optimizing for the perfect component while the game moved to systems thinking.

I'm not less technical now. I'm technical in a different place — constraints, boundaries, direction. The blueprint matters more than the drywall. And every iteration is a chance to push the whole thing forward, not just close a ticket.

The component was the craft. Architecture is the craft now.