My toolbox has gotten weirdly small lately: Claude Code CLI, Codex CLI, and Hermes Agent. Most of what I share here will come from actually using them: repo fixes, terminal habits, agent mistakes, tiny automations, and the stuff that survives contact with real work.

"We could automate that" is becoming a pretty easy sentence to say. Figuring out whether it's worth doing, and getting the person who owns the problem to agree, can take a little longer.

Every new model comes with another round of “you need to learn this.” How much of the week are we supposed to spend catching up? There’s a lot we could already build for someone if we spent some time finding them.

Coding with SI takes a suspicious amount of explaining. Every vague instruction leaves room for a very confident guess. By the time you've described exactly what you want, writing it yourself starts sounding pretty reasonable.

It's easy to give agent gen code the benefit of the doubt when the app looks good. A working screen's a pretty persuasive distraction from whatever's happening underneath.

Most AI agents fail in production because their builders only ever tested them with a human hovering nearby. Yes, they're clever and well prompted, and they ace every demo, but the whole thing was built to impress me in a chat window, like a dog that only does tricks while you're holding the treat. Leave it alone on a quiet Tuesday night and it spends till morning confidently retrying the same failed API call.

AI coding comes with a very confident narrator. Every summary sounds like the credits should be rolling. Meanwhile, you're opening the app to see what actually happened.

If you built lean systems early, your agents are shipping real work while you sleep. If you didn't, you're babysitting automations that need another automation to check on them.

Most agent builders would ship more reliable agents if they studied how their agents fail more than how their agents succeed.

We're asking AI to write the code, then asking AI if the code's good. I'm all for automation. I'd still like to know who's checking the reviewer. Is it another agent? Should it be?

AI's really good at coding the familiar parts. I'm barely looking at the code nowadays. A lot of app-building is connecting those parts. The engineering's in making the whole thing reliable.

One question belongs at the center of your agent workflow: what is the agent allowed to do? The rest of the workflow gets built around that answer.

Every solo builder I know has Codex and Claude Code open at the same time now. One writes the feature. The other explains, politely and at length, why the first one got it wrong.

If you're building with AI, start here. You want apps and pipelines that run without you. Early on, that means giving the agent a smaller job than feels necessary. Reliability comes from clear scope and readable checks. 1. Define one job Pick one process. Write down what goes in and what comes out, or the agent will guess. 2. Set boundaries first List the files it can touch, the commands it can run, and the one thing off-limits. Permissions are cheaper than cleanup. 3. Ask for a receipt Have it report what changed. If the plan shifts mid-run, stop and rewrite it before the failure grows.

My commit history looks emptier since I started coding with AI. My prompts, notes, and half-finished specs folder say otherwise. Most of the typing never makes it into git anymore 😆

The more experienced Claude Code users get, the more actions they auto-approve and the more often they interrupt the agent, according to Anthropic. That combination makes sense. As trust grows, oversight moves from checking every step to watching the run and stepping in quickly. Agent interfaces should make current work visible and redirection easy. anthropic.com/research/measu…

Clear priorities come before agent workflows. As a solo founder, I'm focused on lean systems that help me stay consistent. That's the job I want automation to do.

If every developer suddenly vanished, how long would the following keep running without anyone touching them? - my side project's app store listing - a cron job I forgot about - the "temporary" fix I shipped years ago - my to-do list - the group chat

An agent's permissions are part of its design. If it can make changes I can't easily undo, I want an approval step before it acts.

The only advice I would give someone building with AI: have range. Build an app one week, automate a boring process the next. Wire up a pipeline, then break it on purpose to see what fails. Learn the terminal and the permissions, because the logs will tell you the rest. I try to stay curious enough that very little surprises me.

3,700 of you decided to follow, which is a lot of people to share half-finished experiments with. Thank you for sticking around. I hope some of the advice has helped, and I'll keep sharing what I learn as I go.