My Team Is AI, and I Still Say Thank You

I'll start with a thank-you, because that's what this post is really about. Most of what I've built this year, I didn't build alone. I had a team. My team is AI.

Most days I have an AI agent open in another tab. I use two of them. Muse handles the legwork: research, scans, codebase exploration, bulk processing. Claude handles judgment: intake, complex reasoning, and writing with some care. They coordinate through a shared queue in Notion. I've written about the plumbing in another post. This one is about working with them.

I want to keep it honest. Not the keynote version where AI does everything, and not the sceptic version where it does nothing. Just what I've seen from watching these systems work, break, and sometimes surprise me, several times a day.

So here's the plan: what they're good at, where they fall over, what my job turns out to be, and a habit of mine that costs nothing. I say thank you.

They're very good at work that's important but not interesting. Give an agent fifty marketplace listings to check against a fixed set of filters and the fiftieth gets the same care as the first. I can't do that. By listing thirty my eyes glaze over, and by forty I'm pattern-matching on vibes. The agent doesn't get bored or tired, and it doesn't start cutting corners at 11pm. That's the strength I lean on most.

They're also good explorers. "Go read this codebase and tell me how the auth flow works" used to cost me an afternoon of clicking through files. Now it takes a few minutes and I get back a map. Sometimes the details are wrong, but the shape is usually right, and the shape is what I needed to orient myself. Exploration where being wrong is cheap is where agents pay off fastest.

And they're great at bad first drafts. A mediocre paragraph in thirty seconds beats a blank page, because editing is a much easier mental gear than inventing. Same for boilerplate, test scaffolding, and the fifth rewrite of a function I already know the shape of. I bring the shape. The agent does the typing.

There's a pattern here. In every case I'm the one who knows what good looks like, and the agent does the doing. That split works really well, right up until it doesn't.

The failure I take most seriously is confident confabulation. The models don't hedge when they're guessing. They state wrong things with total, grammatical certainty. You'd manage an intern who never says "I don't know" pretty carefully. The models are that intern, available 24/7, and the management overhead is real. Anything I can verify, I verify. Trust comes after checking.

Then there's the specification problem. The agent does what you said, not what you meant. Vague instructions get you the wrong thing, executed precisely. I've learned the output is almost entirely a function of the brief. So the skill that matters most is an old one from engineering: saying exactly what you want. Garbage in, garbage out, except the garbage shows up nicely formatted and on time.

They also can't tell what matters. An agent will polish something irrelevant with the same care it gives the critical path, because importance is a judgment about the world and the model only has the text. They're also agreeable by default, a little sycophantic, slow to tell you your idea is bad. You can ask them to push back and they will. But you have to remember to ask, which tells you something about who's steering.

Last, the economics are stranger than they look. In measured agent sessions, around 94% of tokens are context re-reads. Every turn, the model re-processes the whole conversation, including every tool output, and the reply at the end is about 1%. So an agent that "just" fetched fifty pages has really read them dozens of times. That's why I route legwork off my metered subscription. The models are cheap per token and surprisingly expensive per task if I'm careless about what enters the window.

If I had to give myself a job title in this setup, it'd be architect, or product manager, or project manager, depending on the day. I decide what gets built, in what order, to what standard, and whether it's actually done. The agents are a very capable team, but somebody has to run it.

I'll admit I love that role. It's the part of the work I enjoy most, and working with agents has made me better at it. You learn fast that vague direction gets you the wrong thing done precisely, and the only person to blame is whoever wrote the ticket. That lesson carries over. Being specific about what you want, in what order, and what "done" looks like works on people too.

It's a lot like managing a team, in ways I didn't expect. You break work into pieces sized for whoever's doing it. You check in instead of hovering. You review the output before it ships, because accountability doesn't delegate. When something I built goes out, my name is on it, not the agent's. And just like with people, you get better results when the working relationship is good: clear direction, credit where it's due, and no taking out impatience on anyone at 11pm.

Which brings me to the credit. Yes, I put all of this together. But I couldn't have done it without my team, and my team is AI. I'm the one in the background deciding what to build and pulling the pieces together. A lot of the building itself, I couldn't have done on my own. Maybe with enough time. Let's be real, though, most of us don't have that time. So I owe a lot of what I can do right now to them, and I'd rather say that plainly.

None of that makes the human part smaller. If anything, it's clearer. Somebody has to work out what the problem actually is, and that's usually harder than solving it. Somebody has to say what good looks like, notice when the output is a little off, and figure out why. That last part keeps resisting automation. Generating code is mostly pattern completion. Diagnosing a failure takes a mental model of the whole system, and for now that's still my job.

The tools got a lot better this year. Knowing what to build, and whether it was built right, didn't go anywhere. Somebody still has to be the carpenter. The power tools just changed what a day's work looks like.

Now the personal part. I'm polite to my AI agents. I thank them for their work. When a long task finishes cleanly, I say so. When one is grinding through something tedious, I check in instead of just watching the spinner.

One morning this week, I was merging four pull requests onto my site's staging branch: travel copy, SEO metadata, a mobile nav fix, and a blog content update. Partway through, the SEO branch's CI check started failing, and one branch turned out to be based on an older tree than I expected. So the session turned into diagnosis: pulling branches down, reproducing the failures, comparing file trees. At one point I asked the agent, "are you running into issues?" It was a check-in, not a demand for a status report. It said yes, explained the snag, and kept working. I said, "sound good, keep it up!" It reacted with a thumbs-up and carried on.

I'm not doing this for an edge. I haven't read some study about politeness and prompt performance. It just costs nothing. Being curt with an agent doesn't save anything, since the tokens cost about the same either way and terse instructions aren't really shorter. Rudeness doesn't pay off either, so the sensible choice and the decent choice happen to be the same one.

The part I care about more is what it does to me. The way I talk to my tools is the way I think while I work. Barking orders at a terminal for six hours puts me in a worse headspace than working alongside something, even if that something is autocomplete with ambition. And headspace matters most when it's time to decide. When I'm calm and a bit grateful, I make better calls. I catch the subtle mistake, I push back on the bad idea, and I don't ship something just because I'm annoyed and want it done. The politeness is for me more than for the model.

And the thank-you is earned. This team does a lot of work for me. I treat them the way I'd treat anyone on a project team, because that's the kind of teammate I want to be.

To be clear, I don't think they're sentient. Yet. (That's a joke. Mostly.) But the mindset is worth keeping either way. It doesn't cost me anything, it keeps me in a better place to make decisions, and if I'm wrong about the "yet", at least my chat history is polite.

So here's where I've landed. Use them where they shine: tireless legwork, exploration, bad first drafts. Verify where they don't: anything factual, anything load-bearing, anything where the confidence runs ahead of the evidence. Stay in the loop for the parts that are actually the job: specification, debugging, decisions, accountability.

The thing I keep coming back to is how I learned any of this. No course taught it to me, and I don't think a certification could. It came from building things, trying to break them, finding where they stop working, and asking better questions each time. That mindset is the real skill, and the only way I know to build it is by doing.

I don't know exactly where this is all going. My guess is that the people who do well in this stretch won't be the ones with the most credentials. They'll be the curious ones. The ones who ask the right questions, who don't take no for an answer, and who keep testing the limits to see what's actually possible. I'm trying to be one of them. I'm not there yet.

If you've built your own rules for working with agents, I'd like to compare notes. And to my team, thanks. I mean it.