i spend most of my day either building agents or working next to them. pretty much every line of code i ship now goes through claude code or codex first. so i have opinions. writing them down here so i can come back in a year and see how wrong i was.
chat was the warm up
most people still use ai like this: you ask something, it answers, then you go copy paste the answer into whatever app you were actually working in. that was fine when the models could only talk. now they can actually do stuff, and the chat box starts to feel like the bottleneck.
the agents i use the most barely feel like chat. i say what i want done, it goes and does it, and comes back with something for me to look at.
i think alot of software goes this way. you stop clicking through menus to get something done, and the menus become the place where you check what the agent did.
the agent has to live where your data is
a seperate ai app you have to go visit is never gonna be that useful. the useful one is the one that already knows your stuff.
take an erp, for example. it already has everything: stock, customers, suppliers, prices, every invoice ever. so when someone asks "which parts are running low", the agent doesnt just answer, it can go draft the purchase orders too.
everyone gets the same models now, so the model isnt really the moat. whoever has the deepest context and the cleanest way for the agent to act on it wins. i'm pretty sure every serious vertical software will have something like this in a couple years.
your job becomes reviewing
when the agent does the work, you go from doing to judging. sounds like a small shift but it changes how you should design the whole product.
the good agent products i've used all kind of do the same things. they show you what they looked at. they stop before anything risky, like drafting an invoice is fine but sending it to a customer should wait for a human. and they make reviewing fast, a clean diff, one click to approve or undo.
this is already how i code. i barely write code from scratch anymore but i read a ton of diffs. the hard part is telling the difference between something thats right and something that just looks right.
a few small agents > one big one
i wrote before about splitting my coding between one agent that plans and one that builds. i keep seeing that same pattern everywhere.
an agent with one narrow job is way more reliable than one that tries to do everything. so i dont think the future is one super assistant. it looks more like a tiny team, and you only step in at the parts that matter.
trust comes in small steps
nobody gives a new hire the company card on day one, same with agents. small stuff first, more once they've earned it.
i think good agent products will make this super explicit, like a slider you move up over time.
the agents that win are gonna be the boring predictable ones, at least in the places where it actually matters.
the part i'm actually excited about
its not about replacing people. its about a small team getting the output of a way bigger one.
the staff at my family's business spend whole days on data entry that an agent could do in like minutes. a two person startup can ship like a ten person one now, i see it every week. that kind of leverage used to only be for big companies, and now basically anyone can have it.
we're still early tbh. alot of agent stuff is amazing in a demo and kinda fragile in real use. but the direction feels pretty clear to me: less chatting, more doing, and people spending thier time on judgement instead of busywork.
gonna keep writing about what i learn building agents. if you're building agents too, hit me up, always down to compare notes.