My Workflow with AI

I’ve never written a line of code. Everything I’ve built, I built by telling an AI what I wanted. We all have access to the same models, but people get very different results from them, and I think that comes down to systems. Code isn’t the blocker anymore, the AI handles that. What it needs is someone to set up the environment for it to do good work. That’s what I’ve spent my time on.

The bigger change was how much I stopped micromanaging. Early on I handheld it through everything, one small step at a time, checking each one. The models are good enough now that I don’t have to. I tell it the outcome I want and let it figure out how to get there. My job moved from directing every step to being clear about the result and having a routine that catches it when it drifts. That routine is what this post is about.

So this is what a normal session looks like for me now, and why each piece is there.

How every session starts

An AI that doesn’t know where you left off will happily redo work, contradict a decision you made last week, or build on top of something that’s already broken. Every other part of this routine depends on it knowing the current state before it touches anything. So the first thing a session does is read.

It reads a short page about who I am and how I like to work. Then it reads a handoff note that says what’s live right now, and for each project it points to a page with the last thing that happened, the exact next step, and anything that’s stuck. When it’s done it tells me, and it says which project it thinks we’re on.

I trust what it can check over what I wrote down. If the handoff says one thing and the project page says another, the project page wins. If the note is more than a day old, it asks me what changed before it does anything. I’ve been wrong about where I left off enough times that this one has earned its place.

Sorting work by how much can go wrong

Fixing a typo and changing how sign-in works are not the same job. If I treat them the same, I either waste a lot of time or I break something that matters. Deciding how much care a job needs, before any work happens, is the thing that keeps the rest of this from being either too slow or too risky. So every piece of work goes into one of four buckets based on how much can go wrong.

• Small stuff like copy, settings, tiny fixes. Look at it, change it, check it, done.
• Normal changes to an app. Build it, test the part that changed, get a second look if it’s worth it.
• Things I don’t fully understand yet, or decisions that are expensive to undo. We talk it through first until I know what I actually want, then build.
• Anything touching sign-in, money, private data, or deleting things. This one gets a short written plan I approve first, a way to undo it if it goes wrong, and a second AI that checks the work before it goes out.

Of everything in here, this is the habit that has saved me the most.

Telling it the outcome, not the steps

If I had to sign off on every file and every small decision, I’d be the bottleneck, and the whole point of this is that I’m not sitting at a desk all day. So I describe what done looks like, as plainly as I can, and I let it choose the path. If the work is clear, it just happens.

I get pulled in when it actually needs me: what should this do, is this risk okay, is this really finished. Finished means it works, it was checked in a way that fits the bucket, and anything risky was said out loud. Not just the AI saying it’s done.

Letting go of the steps only works because the rest of this routine exists. The buckets decide how much checking happens. The second AI catches what the first one missed. That’s what makes it safe to say “here’s what I want” and walk away.

Having a second AI review the work

An AI grading its own work will pass itself. The only review I trust is one from something that didn’t do the work. So when a job needs a review, one AI does it and a different one reviews it.

I used to copy the review from one chat and paste it into the other. Now they hand it off directly and I just read the result. If a check doesn’t produce something I can look at, it doesn’t count.

How every session ends

The reading at the start only works if the last session wrote things down properly. Skip this step once and the next session starts from a lie. So before a session closes, three things happen.

It writes a summary of what happened into that day’s log. It updates the project page with the last event, the exact next step, and anything blocked, and clears out whatever’s finished. Then it syncs the whole thing so my phone and my other computer see the same notes. It tells me when that’s done, and that’s when I close the window.

All of this works from my phone. I read summaries in plain language. I don’t read code.

What happens when something goes wrong

Everything above runs on scripts and notes I can’t debug myself, so I need two things to be true or I’m stuck the first time something breaks.

Every automatic step has the manual version written down next to it. If a script breaks, the instructions for doing it by hand are right there, so nothing depends on a machine I can’t fix.

And when something goes wrong, I don’t just fix it. I ask, how do we prevent this from happening again? The answer becomes a rule that every future session reads, so I explain it once and never have to say it again. Over time that’s what my setup turned into. I’m not guiding the AI down a path. I’m putting up guardrails, and letting it drive between them.