Every developer has a pile of tasks they know could be automated but never get around to automating. After a year of running automation jobs on a fleet of one Raspberry Pi, I've learned that the wins don't come from one big project — they come from small, boring workflows that quietly run in the background.
Here are seven that actually stuck, with enough detail that you can build each one in an afternoon.
1. The Three-Strike Rule
My core rule: if I do something manually three times, it gets a script. Not a perfect script — a working one.
#!/usr/bin/env python3
# strike 3: this task is now code
import subprocess, datetime
def daily_report():
out = subprocess.check_output(["df", "-h"]).decode()
with open(f"reports/disk-{datetime.date.today()}.txt", "w") as f:
f.write(out)
if __name__ == "__main__":
daily_report()
Ugly? A little. It has run every morning for 8 months without me touching it. Perfection is the enemy of automation.
2. Run Agents on a Schedule, Not On Demand
The biggest mindset shift: don't wait until you need something. Schedule it. A cron entry that asks an LLM-backed agent to summarize overnight logs, check for stale branches, or draft release notes means the answer is already there when you sit down.
# 6am daily: agent triages overnight errors
0 6 * * * cd ~/agents && python triage.py --digest >> logs/triage.log
This is exactly the pattern my AI Agent Toolkit is built around — small, single-purpose agents you wire into cron instead of one giant chatbot. $9, and it's the backbone of everything below.
3. Let AI Write the Glue Code
Glue code — the boring 40 lines that connect API A to file B — is the perfect thing to hand to a model. The trick is constraining it:
- Give it the exact input and output schemas
- Forbid external dependencies unless you ask
- Make it print its assumptions at the top
I've stopped writing boilerplate entirely. My job is now reviewing glue code, which takes 2 minutes instead of 30.
4. One Digest Instead of Twenty Notifications
Slack pings, email alerts, failed cron jobs — notification sprawl is its own kind of manual work. Route everything into one queue and have a script produce a single morning digest:
def morning_digest(events):
critical = [e for e in events if e.level == "error"]
return f"{len(critical)} issues / {len(events)} events overnight"
One message, one coffee, zero context switching.
5. A Raspberry Pi Is a Better Server Than You Think
Everything above runs on a $35 board drawing ~4 watts. No cloud bill, no YAML, full control. If you've never deployed to one: flash the OS, enable SSH, install Python, and you have a 24/7 automation server in under an hour. The Pi is also a great forcing function — limited RAM keeps your scripts lean instead of bloated.
6. Make Your Weekly Report Write Itself
I pull commit counts, cron run stats, and uptime into a markdown file every Friday. The "write weekly update" task went from 45 minutes to 3 (I just edit the tone). If you track anything regularly, generate the first draft programmatically.
7. Ship What You Build
The final habit: once a script survives a month of daily use, package it. Write a README, add a one-liner install, and either open-source it or sell it. My bug bounty recon pipeline started as exactly this kind of personal script and became the Bug Bounty Automation Kit — a $15 tutorial + toolkit that now saves other researchers the 40+ hours a week it used to cost me. Even if you never sell anything, packaging forces you to understand your own code well enough to maintain it.
The Meta-Lesson
None of these are technically impressive. That's the point. Automation that survives is boring, small, and scheduled. Pick one workflow from this list this weekend — I'd start with #2 or #4 — and let it compound.
If you want the full stack of agents and scripts behind this post, everything lives in my agent store repo, and the two kits linked above are the fastest way to get it running on your own hardware.
What's the first thing you'd automate? Tell me in the comments — I'll share the script if I have one.
Top comments (0)