Let AI draft the repetitive work

Repetitive work is the best thing to hand to AI for a first draft, but handing it over is not the same as letting go. In our daily operation AiTOM uses several AI assistants, including Claude and Codex, for writing, checking, organising and website work. To make them work together without stepping on each other, we first had to design the rules: who owns which files, who may decide, how far the work has got and how the next person picks it up. This is what we tested on ourselves first.

Where we started

Early on it looked like many teams' first use of AI: open a new conversation, retell the background, receive a draft, copy and paste. One task works fine, but with more work three troubles appeared. First, when a conversation ended the state vanished, and the next day nobody remembered how far we had got. Second, two assistants edited the same file and one change was silently overwritten. Third, items needing a human decision were scattered, and the director had to hunt for questions across many windows.

We judged that the problem was not that AI was not clever enough. It was that the work had not been designed to be resumable, parallel or decidable.

What we did

We turned our way of working into a few explicit rules:

• Several AI assistants may work at the same time, but each claims non-overlapping files and works in its own git branch and working directory, never in someone else's area.
• Shared settings, shared state and commits are handled one at a time, so nobody overwrites anybody.
• The only approver is the human director. AI can draft, check and organise, but does not decide for the director.
• Every decision is logged as a numbered decision record with content, reasoning and date.
• Each work stream has a "work tree": a text tree showing ✅ done, 🔄 in progress, ⏸ waiting, updated every round with the current position marked.
• Handover cards record the stopping point, what is done, what is pending and what to watch for, so another AI can resume after a restart.

The most used piece is the decision card. The AI turns anything needing a human decision into a numbered list, each item with a recommendation. The director replies with one line such as "1 OK, 2 hold", and the AI knows the outcome of each item and carries it out and records it. Decisions stop being a search through long text and become a list and a one-line reply.

Once repetitive work is drafted by AI, people's time moves to what is worth it: judging direction, confirming trade-offs and accepting results. AI drafts and does a first check; people decide. We drew that line on purpose and clearly.

What went wrong and what we changed

The earliest problem was "fluent but unsourced". AI drafts read smoothly but might lack grounds. We added source and evidence rules: facts, observations and assumptions are marked separately, important content carries a source and date, and people spot-check what AI organised.

The second problem was scope creep. When we let an assistant regenerate everything at once, we found unrelated pages quietly rewritten. We now limit each change to a defined scope, check the differences before release and accept only the expected edits.

The third was overwriting. The biggest fear in parallel work is a whole file being replaced by the other side. We require re-reading the current content before writing and confirming the baseline has not moved; if someone else has already changed it, we keep both sets of work and merge or pause the conflicting part instead of overwriting the file. To be honest: these are working rules, not a mechanism that guarantees zero errors, so important steps still get a human check.

What changed

The most direct change is that work can resume. Whichever assistant it is and whether or not a conversation has restarted, reading the work tree and the handover card shows where things stand. The director no longer sees scattered messages, only one tree and one numbered decision card.

Next, parallel work became safe. Different assistants handle different scopes, commits are queued, history is kept and mistakes can be reverted. That lets us push several work streams at once instead of doing one thing at a time.

We have not invented a "percentage of time saved". What we can say with confidence: repetitive drafting and organising really did move off people's hands, while decisions stayed with people.

What you can reuse

• Divide the scope first: each assistant claims non-overlapping files and works in its own branch or working directory.
• Serialise shared state and commits, one person at a time.
• Turn items needing a decision into numbered cards, each with a recommendation, answered in one line.
• Give each work stream a work tree, update it every round and mark the current position.
• Write handover cards so any AI or colleague can pick up after a restart.
• Re-read before writing, and merge or pause on conflict instead of overwriting.

AI drafts, people decide, and the work tree tells everyone where we are.