DEV Community

Cover image for Taming Local Disk Bloat: Where Did My 512GB Mac SSD Go and How to Clean It Safely
Sarmad Hussain
Sarmad Hussain

Posted on Originally published at dustystorage.com

Taming Local Disk Bloat: Where Did My 512GB Mac SSD Go and How to Clean It Safely

#macos #programming #webdev #productivity

Every developer working on a Mac has encountered that sudden, dreaded system alert:

⚠️ "Your disk is almost full"

You open System Settings → General → Storage, hoping for answers. Instead, macOS gives you a massive, mysterious gray bar labeled:

System Data: 142 GB

What on earth is in that 142 GB? Why is it growing? And more importantly: how do you reclaim it without corrupting your active Git repositories or breaking your dev environment?

In this guide, we'll dissect the real culprits behind hidden developer disk bloat on macOS, provide native Terminal commands to find them, and explain how to clean them safely.

1. The Real Culprits Behind Developer Disk Bloat

Standard Mac cleaners scan for browser cookies, language packs, and user caches. But for developers, those are trivial pennies. The real gigabyte-scale storage hogs are buried in your developer toolchains:

Storage Hog Typical Size Where It Hides
Orphaned node_modules 20 GB – 80 GB Forgotten tutorial projects, abandoned feature branches
Xcode DerivedData & Simulators 30 GB – 70 GB ~/Library/Developer/Xcode/DerivedData
Docker VM Overlays & BuildKit 25 GB – 60 GB ~/Library/Containers/com.docker.docker/Data/vms
Gradle & Maven Caches 10 GB – 30 GB ~/.gradle/caches, ~/.m2/repository
Homebrew Downloads & Stale Bottles 5 GB – 15 GB ~/Library/Caches/Homebrew
WhatsApp / Slack Desktop Media 15 GB – 40 GB ~/Library/Group Containers/group.net.whatsapp.WhatsApp.shared

2. Terminal Deep-Dive: Finding Bloat with Native Commands

Before running third-party scripts, let's inspect our disk using native Unix utilities already built into macOS.

Finding Forgotten node_modules Directories

If you've been developing in JavaScript, TypeScript, or React for a couple of years, you likely have dozens of stale projects lingering in your ~/Projects, ~/Sites, or ~/Developer folders.

To find all node_modules folders taking up more than 500MB:

find ~/Projects -name "node_modules" -type d -prune -exec du -sh {} + 2>/dev/null | sort -hr | head -n 20
Enter fullscreen mode Exit fullscreen mode

Warning: Never delete node_modules blindly using global rm -rf scripts while an active project is compiling or using symbolic links.

Finding Xcode DerivedData Bloat

Every time you compile an iOS or macOS app in Xcode, index files, intermediate build objects, and module caches accumulate:

du -sh ~/Library/Developer/Xcode/DerivedData 2>/dev/null
Enter fullscreen mode Exit fullscreen mode

If that folder is over 30 GB, you can safely wipe its contents:

rm -rf ~/Library/Developer/Xcode/DerivedData/*
Enter fullscreen mode Exit fullscreen mode

(Xcode will seamlessly regenerate whatever it needs during your next build).

Inspecting Docker Storage

Docker on macOS runs inside a lightweight Linux virtual machine disk image (Docker.raw or Docker.qcow2). Over time, unreferenced images, stopped containers, and build cache layers expand this virtual disk to maximum capacity:

docker system df
Enter fullscreen mode Exit fullscreen mode

To safely reclaim unused Docker build cache and dangling images:

docker system prune --volumes
Enter fullscreen mode Exit fullscreen mode

3. The Trust Problem: Why Traditional Cleaners Fail Developers

Traditional "one-click" Mac cleaning software operates like an opaque black box:

  1. They report a vague counter: "24.8 GB of System Junk found!"
  2. They ask for full disk access permissions.
  3. They delete files with zero explanation of what they actually were.
  4. And worse: they demand $40/year recurring subscriptions for a basic cron job.

When a cleaner touches a developer's machine, trust is paramount. Deleting a configuration file in ~/Library/Application Support or removing a SQLite database from a local test environment can cost hours of debugging.

4. Introducing Dusty: AI-Explained macOS Storage Management

To solve this trust gap, we built Dusty natively in Swift and SwiftUI.

Dusty is engineered specifically for developers and power users who need complete transparency and surgical control over their disk space.

Dusty UI

Key Architectural Pillars:

  • Plain-English AI Explanations: When inspecting obscure cache files in ~/Library/Caches, Dusty connects to Google Gemini AI to analyze file headers and directory trees. It explains in plain English:
    • What application created this file?
    • Why is it taking up this much space?
    • Is it safe to delete, or will it cause an app to re-index?
  • Developer Bloat Scanner: Directly targets node_modules, Xcode DerivedData, Docker container overlays, Gradle caches, and .next build caches across all project directories.
  • Surgical WhatsApp Media Cleaner: Scans WhatsApp Desktop storage and lets you safely reclaim gigabytes of forwarded videos and audio notes without touching your chat history or ChatStorage.sqlite.
  • Trash-First Safety Architecture: Nothing is permanently deleted without your explicit review. Every cleaned file moves safely to native macOS Trash first, so you can inspect or restore it at any time.
  • Zero Subscriptions: An honest $9.99 lifetime license (with a 24-hour full free trial). Pay once, own forever.

5. Quick Install via Homebrew

You can install Dusty in seconds directly through Homebrew:

brew install sarmadhussainch/dusty/dusty
Enter fullscreen mode Exit fullscreen mode

Or download the universal binary (Apple Silicon M1/M2/M3/M4 & Intel) directly from the official website:

🔗 https://dustystorage.com

GitHub Tap: https://github.com/sarmadhussainch/homebrew-dusty

Summary Checklist for Developer Disk Hygiene

  1. Run find or use an analyzer to audit old node_modules directories.
  2. Flush ~/Library/Developer/Xcode/DerivedData every few months.
  3. Run docker system prune when disk space dips below 20%.
  4. Clean WhatsApp Desktop forwarded media attachments.
  5. Keep your Mac SSD at least 15% free so APFS wear-leveling and swap memory perform optimally!

What's the biggest storage hog you've discovered on your Mac? Let me know in the comments below!

Top comments (0)