Building with agents

There is a difference between asking an AI what to do and watching an AI do it.

The first is a conversation. The second is closer to delegation.

That changes the work.

Most people still use AI as a faster way to think out loud. They prompt, receive, judge, rewrite. The loop is familiar. The model assists. The person decides.

Agents change the shape of that loop.

Give an agent a goal and it can start moving toward it. It reads the file, checks the error, writes the fix, runs the test, reads the next error, and tries again. It does not wait for every instruction. It does not stop at every fork in the road.

That is useful.

It is also where the work becomes easier to lose sight of.

What agents actually do

A model answers what you ask.

An agent works toward what you asked it to accomplish.

That difference sounds small until you watch it happen. The agent is no longer only producing text or code. It is making intermediate choices: which file to open, which pattern to follow, which issue to fix first, which path looks most likely to work.

Some of those choices are obvious. Some are not.

The danger is not that the agent gets everything wrong. The danger is that it gets enough right that you stop looking closely.

You accept the working result without understanding what was traded away to get there.

The new judgment

Working with agents does not remove judgment.

It relocates it.

Less judgment sits inside execution. More of it sits before and after: in the direction you give, the boundaries you set, the review you perform, and the moment you decide to step back in.

The questions change.

Not: how do I write this function?

But: is this the right structure for what I am building? Did the agent solve the problem I meant, or just the one I described? Is this abstraction worth its weight? Would I still choose this path if I had made every step myself?

That is the new work.

Not typing every line. Owning every decision.

Delegation has a shape

Some work is good agent work.

Scaffolding. Boilerplate. Refactors. Integration patterns. Format changes. Repetitive fixes. Tasks where 'working' is close enough to 'done,' and where you can judge the output clearly.

Other work should stay closer to the person building the product.

What should this feel like? What should be shown first? What should be left out? Where does the product need to be opinionated? What does 'good' mean here?

Those decisions can look like implementation details.

They are not.

They are the product.

Owning the output

Products built with agents are still products someone chose to build.

The agent did not decide the thing should exist. It did not know who it was for. It did not understand what would make it useful, specific, or worth keeping.

That authorship remains human.

What changes is the metabolism. The distance between idea and working product is shorter now. Short enough that the bottleneck moves. The hard part is no longer always making the thing run. It is knowing what should run in the first place.

That requires a different posture.

Less operator. More editor.

Less 'can this be built?' More 'should this be the thing?'

Agents can carry more of the making.

But direction still has to come from somewhere.

The product is not what the agent outputs.

The product is what someone decides to keep.