How to automate repetitive dev tasks with AI agents

Some work you finish. The rest just comes back. Dependency bumps, issue triage, the changelog, that one flaky test: every week the same chores return, and every week they eat the hours you meant to spend building.

AI coding agents changed how fast you can write code. Most developers still run them the same way, though: open a session, type the same prompt you typed last Tuesday, watch it work. If you're re-typing a prompt on a schedule, you've found work that shouldn't need you at all. Here's how to hand it over for good.

The chores worth automating

Repetitive dev work has a shape worth noticing: the scope is bounded, "done" is easy to define, and it repeats. That's not the annoying edge of software work; it's the ideal shape of an agent task. The usual suspects:

• Dependency updates. Bump what's outdated, run the test suite, and write up what changed and what broke. Worth sorting that queue first: part of it is bot work, part of it isn't.
• Issue triage. Read everything new, try to reproduce, apply labels, and draft a first reply, or a task card for the real fix.
• Changelog and release notes. Turn the week's merged work into something humans actually want to read.
• Test health. Re-run the suite, hunt the flakes, and report which failures are real.
• Docs drift. Compare the README and docs against the code they describe and flag what's gone stale.
• Code hygiene. Sweep for dead code, unresolved TODOs, and the lint warnings everyone stopped seeing.

None of these are hard. That's exactly the problem: they're easy enough to lose every priority fight, and important enough that skipping them quietly hurts.

Write the brief once, improve it forever

Hand-run automation has a hidden cost: every time you re-type the prompt, you type it a little differently, and the agent's output wobbles with it.

The fix is to treat the prompt like code. Write the chore down once as a real brief (what to do, what "done" means, what to leave alone) and reuse it verbatim every run. When the agent misses something, you don't sigh and fix it live; you improve the brief, and every future run inherits the fix. Six weeks in, your dependency-update prompt knows about the one package you pin, the changelog format you like, and the tests that actually matter.

That's the compounding trick: one-off prompts evaporate, a maintained brief gets smarter every week.

Automation still needs a review lane

An agent on a schedule is doing work while you're not watching, and that should make you slightly nervous. It makes us nervous too. The answer isn't to stay hands-on forever; it's to keep the last step human:

• The agent proposes; you approve. A run should end in something reviewable (a diff, a summary, a card in a review column), not in silently shipped changes. The habits from reviewing AI-generated code apply doubly to code nobody asked for this morning.
• Journal every run. If you can't see what the automation did last night, you'll stop trusting it, and rightly so.
• Start supervised. Run the chore manually a few times with the same brief before you put it on a timer. Schedule it once it's boring.

From ritual to Loop

You can get surprisingly far with a text file of saved prompts and a weekly reminder, and a one-shot chore can even graduate into a real script via headless mode. But the whole point was to stop being the trigger.

That's what Loops are for in SanuDesk, the desktop app we build for running AI coding agents. A Loop is a chore with a schedule: write the brief once, pick how often it fires, and it launches an agent run on its own, journaling every result so you can read exactly what happened and when. Chores that produce real work drop cards onto the project's Kanban board, where they queue up for the rest of your fleet and land in review like any other task.

And because SanuDesk drives the Claude Code, Codex and Gemini accounts you already pay for, your automation runs on your own models: no separate credit meter deciding whether the nightly cleanup is worth it.

Start with one chore

Don't automate your whole maintenance list this weekend. Pick the single most annoying recurring job (the one you notice yourself resenting) and write the brief. Run it by hand for a week or two, tightening the prompt each time. When the results get boring, put it on a schedule and take yourself out of the loop.

That's the quiet win of agent automation: not a dramatic demo, just a Tuesday where the dependencies bumped themselves, the issues arrived pre-triaged, and you spent the morning building.

Download SanuDesk free and give your agents a desk, then, when a chore has earned it, turn it into a Loop. See how Loops, boards and tiled sessions fit together on the features page.