How to Automate Boring Tasks With AI Agents

Playbook

There's a category of work that's too small to hire for, too tedious to enjoy, and too frequent to ignore: renaming a hundred files, pulling numbers out of yesterday's logs into a weekly report, applying the same edit across forty documents. This is the sweet spot for AI agents. The task is well-defined, the "did it work" check is obvious, and you don't need the smartest model on earth — you need a fast, cheap one that gets a clear chore done. Here's how to hand a boring job to an agent safely, without waking up to find it "helpfully" deleted the wrong folder.

Step 1: Pick a chore that's boring, repetitive, and checkable

Good automation candidates share three traits. They're repetitive — you do them the same way every time, which means the rules can be written down. They're boring — no judgment calls, just mechanical steps. And crucially, they're checkable — you can look at the result and instantly tell if it's right. File wrangling, report generation, and bulk find-and-replace-style edits all qualify. If a task needs real judgment or has a fuzzy definition of "done," it's a bad first automation. Start with something so mechanical it's almost insulting; that's the point.

Step 2: Work on a copy, always

Before an agent touches anything real, make a copy. Automation acts on actual files and data, and the whole risk is that a slightly-wrong script does slightly-wrong things to a lot of them at once. Point the agent at a duplicate of the folder, a test dataset, a scratch directory. When the output is correct on the copy, then you run it for real. This one habit turns "the agent wrecked my files" into "the agent wrecked a copy of my files, which I threw away." Cheap insurance against the exact failure mode that matters.

Step 3: Prefer a dry run

Better than a copy is a script that shows you what it would do without doing it. Ask the agent to build automations with a dry-run mode: print "would rename A to B, would delete C" instead of acting, so you can read the plan first. For 200 files, you skim the plan, spot the one wrong case, fix the rule, and only then run it for real. A dry run turns a scary bulk operation into a reviewable list. Make it the default for anything that renames, moves, or deletes.

Step 4: Use a cheap, fast model — it's plenty

This is the good news about automation: you do not need a frontier model. Writing a script that walks a directory, transforms some text, and produces a report is squarely within the range of fast, budget models. Reserve the expensive reasoning models for genuinely hard problems; a file-renaming script isn't one. A fast model like Gemini Flash (around $1.50 / $9 per million tokens) or a budget model like DeepSeek (around $0.435 / $0.87) handles these chores comfortably, and because you'll iterate a few times to get the rules right, cheap-and-fast wins over slow-and-brilliant. The whole appeal of automating small chores is that it's cheap; keep it that way.

Step 5: Hand off the chore with clear rules

Automation lives or dies on how precisely you state the rules. Vague instructions produce a script that's confidently wrong. Spell out the input, the transformation, the edge cases, and what to do when something's unexpected. Here's the prompt shape we use:

Write me a script to automate this chore. Fast, simple, readable.

INPUT: <where the files/data are, and their format>
TASK: <the exact transformation, step by step>
RULES:
- Run on a COPY / with a --dry-run flag by default: print what
  it WOULD do (rename X to Y, skip Z) without changing anything.
- Only act for real when I pass an explicit --apply flag.
- Handle these edge cases: <empty input, missing field,
  a file that already exists, etc.>
- If something is unexpected, skip it and log it — never guess
  or overwrite silently.

Show me the script so I can read it before I run anything.

Step 6: Read the script, then run the dry run, then apply

The order is the safety. Read what the agent wrote — automation scripts are short, so this takes a minute and catches the obvious disasters (a wrong path, a missing filter). Run the dry run and check the printed plan against reality. Only then apply it for real. Every step here exists to put a human checkpoint between "the agent produced a script" and "the script mutated my actual files." Skip the checkpoints and you've automated a mistake.

Step 7: Schedule it once it's trustworthy

The real payoff comes when a one-off becomes recurring. Once a script has run correctly a few times by hand, you can schedule it — a cron job, a scheduled task — so the weekly report just appears and the file cleanup just happens. But earn that trust first: run it manually until you're confident, then automate the trigger. A scheduled script that runs unsupervised is only as safe as your confidence in it, so front-load the checking. And keep the dry-run mode around even after scheduling; when the inputs change unexpectedly, you'll want to see the plan again.

What to automate first

If you're stuck for a starter, the classics never fail: batch-rename and organize a messy downloads folder, generate a summary from a pile of CSVs, convert files from one format to another in bulk, or scrape a table off a page into a spreadsheet. Each is boring, mechanical, and instantly checkable — the exact profile that makes automation safe and satisfying.

Automating chores is where AI coding quietly gives you hours back, as long as you keep the copy-first, dry-run-first discipline. Because these tasks are cheap to run, the model choice matters — the best AI for automation scripts covers who to route them to, and when a chore grows into a proper little program with a real interface, building a CLI tool with AI is the natural next step.