Is it safe to
let it run?
You can edit a draft and catch a confident lie. Those protect your work. This chapter protects everything else: the moment the AI is not just writing, but doing. Sending the email, changing the file, spending the money. The skill here is deciding what it is allowed to do before it does anything, so the worst case is small.
The fear of letting AI act on its own is healthy. The answer is not to never let it act, and it is not to let it do anything. It is to decide in advance which mistakes are even possible. You set the boundaries when you are calm, so a bad call in the moment runs into a wall instead of into your bank account.
Think about how you would hand tasks to a brand new assistant on their first day. Some things they can just do: draft replies, organise notes, make suggestions. Some things they must check with you first: sending anything to a client, spending money, deleting things. And some things they must never do, no matter what: touch the payroll, email the whole list, wipe a folder. You would not write that list in a panic. You would write it on day one. Same here.
Sort every action the AI might take into three buckets. This ladder is the course\u2019s own framing, a simple way to think about how much rope to give. Most beginners never draw the line at all, which is the actual danger.
The point of writing it down is that the line holds even when you are not paying attention. You build the guardrail once, and then a mistake simply cannot happen, because the dangerous action was never available. This is the same idea behind the tools builders use to physically block destructive commands: make the bad outcome impossible rather than relying on being careful every time.
Here is an autonomy boundary you can paste into a project\u2019s instructions. It tells the AI exactly which bucket each kind of action lives in.
One more practical thing, because it bites beginners on longer tasks. A conversation has a working memory, and it is finite. Pack too much into one long chat and the model starts to lose the thread, a drift sometimes called context rot: it forgets earlier instructions, contradicts itself, gets sloppy. The fix is to keep the working memory clean. Start a fresh chat for a fresh task, and do not let one conversation sprawl across ten unrelated jobs. A focused chat stays in the smart zone. A bloated one drifts into the dumb zone. (The smart-zone idea comes via Matt Pocock, crediting Dex Horthy.)
For your thread project, write your own Always / Ask / Never list. Be specific to what your project actually touches. Then stress-test it: think of the single worst thing the AI could do in your project, and confirm your Never bucket would have stopped it. Paste the boundary into your project instructions.
Show the worked solution
- Safety is not never letting it act. It is deciding in advance which mistakes are even possible.
- Sort every action into three buckets: Always (just do it), Ask (get my yes), Never (off the table).
- Write the boundary when you are calm, so a rushed click in the moment cannot reach the dangerous actions.
- A conversation’s working memory is finite. Keep chats focused so the model stays in the smart zone and does not drift.
Your thread project now has an autonomy boundary in its instructions. That completes Part 4: you can edit its drafts, catch its confident mistakes, and contain its actions. Your project is no longer just capable, it is safe to actually use. From here we stop protecting and start building: Part 5 is where you make real things.
The hype says hand it the keys. The honest version is better: decide which doors it can open, lock the ones that matter, and then you can let it move fast without holding your breath.