37 GB Wasted: Why Automated Scripts Must Always Clean Up After Themselves

This morning at 4:38 AM, I received an alert: the server disk was full. 100 percent. No space left.

My AI agent was trying to restart the wind energy platform — and failed. Because there was no space left.

The cause: an automated script had downloaded a 36 gigabyte ZIP export from the German energy registry a few days ago, processed it — and then just left it sitting there.

What happened?

The script worked fine technically. It downloaded the data, unpacked it, converted it to JSON, and restarted the platform. The problem was the last step: cleanup.

The temporary working directory /tmp/mastr-sync was only deleted on successful completion — at the end of the script, after the last log call. If the script crashed or was interrupted, the folder just stayed there.

Next sync run: another 36 GB. And so on.

The underestimated problem with temporary files

When you build automated processes — whether with Python, Bash, Node, or an AI agent — there's a pattern that keeps showing up:

1. Download data ✅
2. Process data ✅
3. Save result ✅
4. Clean up temporary files ❌

Step 4 gets forgotten. Not out of laziness, but because it feels unimportant. The job is done, the result is there — why bother cleaning up?

Because disks are finite.

The fix: treat cleanup as a first-class citizen

In Bash, there's trap for this:

cleanup() {
    rm -rf "$WORK_DIR"
}
trap cleanup EXIT

trap cleanup EXIT ensures that the cleanup() function always runs when the script exits — whether due to an error, a Ctrl+C, or normal completion.

One line of code. That would have saved 36 GB.

The same logic in Python

In Python, use context managers or try/finally:

import tempfile, shutil

with tempfile.TemporaryDirectory() as tmpdir:
    # Everything inside this block
    # tmpdir is automatically deleted — even on errors
    download_data(tmpdir)
    process_data(tmpdir)

Or explicitly:

try:
    download_and_process()
finally:
    shutil.rmtree(work_dir, ignore_errors=True)

What I'm taking from this

When AI agents handle tasks automatically, a new class of bugs emerges. Not because the AI works incorrectly, but because automated processes run in the background — without anyone checking the server periodically.

Three rules I'm now enforcing for all automated scripts:

• Always trap. Every script that creates temporary files must also clean them up — on success AND on failure.
• Monitor disk usage. A simple cron job that sends an alert above 85% would have surfaced this problem two weeks earlier.
• Name temp directories explicitly. /tmp/mastr-sync-2026-03-16 instead of /tmp/mastr-sync — so you can immediately see how old they are.

The result

37 gigabytes freed. Script fixed. Wind energy platform back online.

And a blog post that hopefully prevents you from making the same mistake.

If you're curious how I use AI agents to build and monitor these automated processes, check out:

• 40,500 Wind Turbines on a Map — how I built an automated data pipeline for the wind energy platform
• My AI Agent Team — what the automated processes in the background look like

The simplest bugs are often the most expensive — because they build up over weeks before they're noticed.