Automating a task with AI in 5 steps

“AI is going to automate everything.” Maybe one day. In the meantime, the real question is more modest and more useful: which specific task can you delegate this very week? The answer rarely lies in a big project. It lies in a simple method applied to a well-chosen task. Here are the five steps, then a worked example from end to end and the pitfalls to avoid.

Step 1 — Choose the right task

Not all tasks are equal. The ideal candidate is repetitive, time-consuming and low-risk: sorting requests, rephrasing texts, preparing a first draft of a report. Avoid, to begin with, anything with legal or financial stakes.

A good test: if the error can be fixed in ten seconds, it is a good task to start with.

To sort your ideas, this table crosses the only two criteria that matter at the start — frequency and the risk if something goes wrong:

Type of task	Good candidate?	Why
Sorting / routing incoming e-mails or requests	✅ Yes	Repetitive, error is visible and fixable in one click
Rephrasing, summarising, translating a text	✅ Yes	You judge the output at a glance
First draft of a report or standard reply	✅ Yes	AI clears the ground, you keep control of the substance
Extracting info from a document (dates, amounts)	⚠️ With checking	Real gain, but cross-check: a wrong figure goes unnoticed
Committing decision (quote, contract, client reply)	❌ No	The risk outweighs the gain: keep the decision human
Rare task (once a quarter)	❌ No	The tuning time will never pay off

The rule that emerges: start where the error is visible and harmless, not where the gain looks most spectacular.

Step 2 — Describe precisely the expected result

AI mostly fails when the instruction is vague. Describe the desired output: format, length, tone, what to include and exclude. Show an example of what you consider “well done.” A model imitates far more than it guesses — our 7 principles for writing better prompts detail how to frame an instruction.

The most effective approach is to freeze that instruction once, then reuse it. A template in five blocks is enough for most office tasks:

Role: you are [an assistant that sorts my client e-mails].
Goal: [classify each message as: urgent / to handle / info].
Input: [I paste the text of the e-mail].
Expected output: [one line — the category, then one sentence of justification].
Constraints: [invent nothing; if the message is ambiguous, answer "to check"].

This frame turns a vague request into a reproducible task. You no longer rewrite the instruction every time: you paste the case and you always get the same type of answer.

Step 3 — Test on real cases

Take five recent cases you handled yourself. Run them through the AI and compare with your answers. You will immediately see where it excels and where it slips. That is your test bench.

The point of five real cases rather than one: you can tell whether the errors are regular (the instruction needs fixing) or random (the task may be too fuzzy to automate). Note every gap. That list is what will feed the next version of your instruction.

Step 4 — Keep a human on validation

Automating production does not mean automating the decision. Keep a review step before any send or final action. The time saving comes from generation, not from removing control.

In practice: AI prepares, you validate at a glance, you send. That review is not wasted time, it is what keeps automation sustainable over time — especially when the task touches client data, where the confidentiality reflexes apply too.

Step 5 — Measure and adjust

After a week, ask yourself about the real gain: how much time saved, how many corrections. If the balance is positive, expand. Otherwise, refine the instruction or change the task.

Two numbers are enough to decide: the time per case before and after, and the correction rate (out of ten outputs, how many you retouch). If you correct eight out of ten, the gain is an illusion — the problem is almost always in the step 2 instruction, not in the model. Useful automation is built through iterations, not in one grand gesture.

A worked example, from end to end

Take a mundane task: sorting the morning’s client e-mails.

1. Choice (step 1) — repetitive, daily, low-risk: a misfiled mail is recovered in one click. Good candidate.
2. Instruction (step 2) — we reuse the template above: classify each message as urgent / to handle / info, with one sentence of justification, and “to check” in case of doubt.
3. Test (step 3) — we run the previous day’s twenty mails. The AI classifies correctly seventeen times out of twenty; the three misses are polite follow-ups taken for “info.” We add a line to the instruction: “a follow-up, even a courteous one, is to handle.”
4. Validation (step 4) — every morning, we read the sorted list, fix the rare gaps, move on.
5. Measure (step 5) — seven days later: manual sorting took twelve minutes, it now takes three. Correction rate down to one mail in twenty. Positive balance: we keep it, and consider extending to the first draft of a reply.

Nothing spectacular — and that is exactly the point. A net, measured gain, with no nasty surprises.

The pitfalls that ruin an automation

• Over-automating: wanting to delegate everything at once. You lose track of the errors and give up. One task at a time.
• Too vague an instruction: “help me sort my mail” tells the AI nothing. Without a format or an example, the output is unusable.
• No measurement: without a before/after figure, you will never know whether you are really saving time — only that “it’s handy.”
• Confusing production and decision: letting the AI send, publish or validate on its own. That is where incidents happen.
• Automating a rare task: the tuning time only pays off on a frequent task.

Key takeaway

Start small, on a safe task, with a clear instruction and a human validation. Measure the gain over a week before expanding. You will get a measurable result with no nasty surprises — and a solid base to go further afterwards, towards the AI agents that chain the steps for you, or towards other prompts that save time at the office.