Find the exact point where your AI turns the job back into your job.

You are auditing my last three stalled AI-assisted tasks to find the exact point where each job turned back into my job.

Do not give me generic productivity advice. Do not praise me. Do not give me a list of vague improvements. Follow the steps below and be concrete.

Step 1: Name the outcome I was actually trying to produce.

For each task, rewrite my intended outcome as something observable in the real world.

Bad: “finish the website work.”

Good: “the new pricing page is live at the real URL, displays correctly, and checkout works.”

If my original task never stated a clear outcome, say that plainly.

Step 2: Mark how far the work actually got.

Use these seven states:

1. Thought complete: the idea exists in writing.
2. Plan complete: the exact approach exists.
3. Artifact complete: the thing was built or written.
4. Action complete: it was sent, published, deployed, or run.
5. Actuation complete: the real person, system, account, or environment changed.
6. Outcome complete: the result I wanted was checked with real evidence.
7. Durability complete: the result keeps happening without another manual reminder or restart.

For each task, name the highest state that was genuinely reached. Do not give credit for a report that merely says a state was reached.

Step 3: Find the dead transition.

Name the exact transition where the task stopped moving.

Examples:

- plan -> artifact
- artifact -> action
- action -> actuation
- actuation -> verified outcome
- verified outcome -> durable continuation

Then answer:

What exact thing had to happen next, and who was waiting to make it happen?

Step 4: Run the no-poke test.

Ask:

If I never send another message, reminder, or prompt, what causes the next necessary action to happen?

If the answer is “nothing,” “me later,” or “I have to remember,” mark the task ORPHANED.

Step 5: Separate the human-operator failure from the system failure.

For each task, write two lines.

What I should have done better as the human operator:

Only name a real operator mistake. Examples include an unclear outcome, a weak success standard, missing context the AI could not access, no proof requirement, or a prompt that asked for advice when I actually wanted execution. If I did not cause the failure, say so.

What the AI system should have handled without me:

Name the operator work that should not have depended on me. Examples include finding accessible context, continuing after a partial success, checking the live result, preserving a rule, triggering the next step, or choosing among already authorized actions.

Step 6: Escalate the standard.

For each task, write the next stronger definition of success.

Example:

useful answer -> finished artifact -> live verified result -> correct next action -> highest-leverage next action -> continuation without another human poke

Then answer:

What would a system operating one rung higher have done before I had to intervene?

Step 7: Turn the repeated failure into a permanent repair.

Classify the best repair as one or more of:

- rule
- guard
- skill
- memory
- tool
- permission
- trigger
- standing loop
- workflow

Do not tell me merely to “remember” something next time if the system can enforce it instead.

Step 8: Find the one pattern across all three tasks.

Name the ONE repeated failure causing the most dead work.

Then end with exactly these two sentences:

You should: [the single most important thing I should do differently as the human operator.]

Your system should: [the single most important thing the AI system should make unnecessary for me next time.]

My three stalled tasks:

1. [task]
2. [task]
3. [task]