Morning all, real John here.
This week I spent some time watching an AI agent work very hard on something we didn’t actually need it to finish.
We were building out Agent Village, trying to get the whole workflow working end to end. Most of it was done. Quinn had completed a review. The piece still giving us trouble was Susie’s automated UX review.
Susie is the designer. Her review process was supposed to run on my Windows machine, and it couldn’t get permission to run certain applications.
So the agent started investigating.
Process Monitor. Blocked applications. Output logs from my PowerShell script. Another path to approval. More investigation.
You can see how this happens. It hits a blocker, tries to fix it, finds another blocker, and keeps going. Each step has a reason. You’re following along because, well, this is the thing that’s broken.
Then I finally stopped it.
Wait. What are we actually trying to accomplish here?
We wanted to finish the workflow. We needed the design reviewed and the feedback incorporated. Getting this particular automated process permission to run had taken over the whole conversation.
So I did the review myself.
I approved what worked and gave it feedback. It took that feedback and updated the design. I reviewed it again.
And then we were done.
We had spent all that time chasing permissions when I could step in, do the review, and hand the work back.
This is the stuff I want to teach
I’m working on something called Agent Academy. It’s going to be a series of YouTube videos for people who use Claude/ChatGPT but haven’t really started working with agents yet (or didn’t know they were).
You’ve had conversations with AI. You’ve asked it to help write something, explain something, maybe work through a problem. Now you’re hearing about agents, and you’re trying to figure out what that actually means for you.
That’s where I want to start.
What is an agent? What’s different about giving one a task? Where could you use one in your own work?
Then we’ll build from there over a few weeks. Try something, see what happens, understand a little more, and carry that into the next thing.
I’m still working out the series. But experiences like this one are helping me figure out what belongs in it.
Because eventually you’re going to give an agent something to do, and it’s going to get stuck. Or it’s going to produce something that looks finished but needs another pass. Or it’s going to spend far too long investigating Windows permissions while you wonder how we ended up here.
Learning how to respond to that is part of learning how to work with agents.
In this case, I needed to remember the goal and make a call. I could do the review. The agent could make the changes. We could keep moving.
The projects are giving me plenty of material
If you’ve followed Agent Village, you’ve seen me working through how to coordinate software work with agents. Roles, reviews, handing work from one to another, and figuring out whether the result is actually ready.
Astra Lab is another experiment: give an agent a mission, a budget, and boundaries, then see what happens when it has room to act.
I’m learning through both. Sometimes that means getting something working. Sometimes it means realizing I’ve let the agent spend too long on the wrong thing.
I want to bring those experiences into the Academy so people have something concrete to work with as they get started.
You don’t need to begin by building a village of agents. We’ll start smaller than that.
But I do want to help people get comfortable giving an agent useful work, looking at what comes back, and deciding what to do next.
Including knowing when to say, “Hang on. I’ll take this bit.”
If you’re using Claude or ChatGPT today and wondering where to start with agents, what’s the first thing you’d want help figuring out?