Working with AI, between loss and emergence

In 2018 I spent weeks scraping and hand-labeling hundreds of tree-leaf photos per species for a classifier that never cleared 85% validation accuracy. I'd just taken Jeremy Howard's fast.ai courses, and "neural network" was a phrase I said with a bit too much enthusiasm. To label the data I first had to learn to tell the species apart myself; for that model, I was the ground truth. I didn't realize at the time that I was looking at the whole job description. The models have changed beyond recognition since, but the work is still that: being the thing the output gets checked against.

The eras after that went by fast. An early GPT-3 key let me build a toy that took in code on the left side of the screen and explained it on the right - a direct spiritual ancestor of everything that has followed since, however at the time I pretty much filed it under "neat trick" regardless. Then ChatGPT, when the whole world looked up at once, and even then the furthest we were really thinking was replacing Googling and sifting through Stack Overflow. Then a blur of model releases, context management, tool use, harnesses.

Then agents. The first time I handed off a real task and watched it get done while my hands stayed off the keyboard, something shifted underneath me. I wasn't writing the code anymore; I was directing it. That shift has propelled many a developer into a full-blown identity crisis, and understandably so. The nature of the work is changing enough to deserve real reflection - about the job, but also about what the job was doing for us all along.

The loss

A lot of my excitement for agentic workflows comes from trimming the fat: delegating the busywork, the speed, the parallel work. But the deeper I lean in, the more I notice the side effects.

Because what really is fat here? The uncomfortable truth is that some of what looks like fat is load-bearing. The slow iterations, the chiseling, the hand-labeled leaves: that friction was building my taste all along. Those were the reps that calibrated my eye for good versus good enough. And that's exactly what's at risk. The danger is a slow decoupling: output stays high while judgement quietly thins. Ground truth, it turns out, needs maintenance.

Michelangelo supposedly said sculpting was a matter of removing everything that isn't David. Our tools remove the marble fast. But do we still know where David is? The loss here comes from a change in altitude. Agentic engineering let me zoom out and keep momentum, spending far less time stuck in the weeds. The cost is distance - from the work itself, and from the close, hands-on contact that keeps craft sharp.

The emergence

None of this is an argument for retreat. The loss is real, but it stays manageable as long as I'm deliberate about it, and the other side is worth the vigilance. Working at this altitude has let me build things I'd never have attempted alone and ship at a pace that used to be fantasy, while spending my attention on the parts that need a human. The tools getting smarter is exciting, but the shape of the work itself shifting is even more so. The new shape has room for a particular kind of person: someone who can move fast and still knows what's worth slowing down for.

That doesn't happen by default. So I still set aside time to write code by hand, to sit with a problem before reaching for a model, and to keep learning the things I could now technically skip. Not out of nostalgia, but because those are the reps that keep my judgement worth trusting. This is the answer to the identity question too: the identity was never "the person who types the code." It was the person who knows what good looks like - and that part doesn't get delegated.

The way forward

In practice, I split the work deliberately in two. At altitude, my workflow has climbed the same ladder as the field's: editor copilots first, then CLI agents and orchestration tools, playing each model to its strengths. Every rung is a step up in abstraction - and another step of distance from the keys. The trend points further still: away from managing agent sessions by hand, toward whatever orchestration layer sits above them.

And on the ground, I keep a running list of things to build by hand precisely because I could skip them: right now, a basic RAG system, an agent pipeline, an eval harness. These happen to be the building blocks businesses are reaching for as they fold AI into everything - but that's almost beside the point. The point is contact. The tools will only get faster; staying sharp enough to aim them well is the part I have to keep choosing.