Two Macs, One SSD, and the Sync I Stopped Trusting

The moment iCloud ate my tools

I used to let iCloud handle Desktop & Documents with Optimize Mac Storage turned on. At some point it removed node_modules from a project folder. Local tools started hanging and commands failed.

Since then, I stopped trusting automatic sync for anything that has dependencies, build artifacts, or tooling glued to it. If a service thinks a folder is “just files,” it will treat it like “just files.” Most developer setups are not “just files.”

My current setup is:

• Mac Studio at the studio
• MacBook Air at home
• A Samsung T9 SSD that lives in my bag

The hardware is boring. The rules are what keep work from vanishing.

Rule 1: Anything with dependencies lives outside iCloud

After the node_modules incident, I moved everything with dependencies into ~/scripts. That includes:

• Local tools
• Small internal utilities
• Anything that expects its own node_modules, venv, or similar nearby

The point is not the exact folder name. The point is that this folder does not sync. iCloud can keep its hands off. No “optimized” storage, no surprise cleanups.

This solves a few problems at once:

I wrote about this earlier in Why Littlebird Sits At The Center Of My AI Stack.

• Tools work the same on both Macs, as long as I set them up the same way.
• Nothing important is at the mercy of a storage optimization algorithm.
• I know where to look when something breaks: ~/scripts, not some nested iCloud path.

If you keep your projects in Desktop or Documents and let a sync service manage them, you are mixing “working directory” and “backup/sync target” in one place. That works, until it doesn’t.

Rule 2: Notes live on the Mac you wrote them on

My Obsidian vault is not synced between the two Macs. Each machine has its own local vault. A note I write at home lives on the MacBook Air. A note I write at the studio lives on the Mac Studio.

This is sometimes inconvenient. The upside is that the notes are always there, offline, and not waiting for some sync state to resolve. No conflicts, no half-merged files, no “where did that note go?” feeling.

The trade-off is simple:

• If a note needs to exist everywhere, it should not live only in Obsidian.
• If a note is tied to a place or a machine (like studio-only planning), Obsidian is fine.

Instead of assuming every note must be everywhere, I treat each vault as local context. The Mac in front of me holds the notes for the work I usually do there.

Rule 3: Projects live on the T9 or GitHub, not in sync folders

Active projects either live on the T9 SSD or in a private GitHub repo.

More on this in my article Build in Public with Less Friction: My Real-Time Dev Diary Using NoteVault.

The T9 handles the physical side of the workflow. If I know I will move a project between studio and home, it goes on the SSD. I plug it into whichever Mac I am using and work directly from there. No waiting for sync, no wondering if the latest commit made it across, no duplicated folders with slightly different names.

For anything that fits well into Git, the private repo is the source of truth. The code lives there, and the local clones on each Mac are just working copies. If the Mac disappears, the project does not. The T9 and GitHub cover different failure modes, but they share one idea: the project is anchored somewhere specific that is not “maybe synced.”

Two Macs, one brain: how this feels day to day

With this setup, each Mac has a personality:

• Mac Studio: heavier projects, studio-specific notes, tools in ~/scripts.
• MacBook Air: lighter work, home notes, the same ~/scripts pattern.

The T9 is the shared workspace. If a project is in motion between the two places, it lives there. If it is stable and versioned, GitHub owns it. The missing piece is blind trust in sync. I use sync for what it is good at (simple documents, photos, small files) and avoid it for anything that breaks when a folder quietly disappears.

This is not the most convenient or elegant setup. It is predictable. When something is missing, I can usually answer:

Read also Upgrading three Tailwind projects to v4 in one sprint.

• Is it a tool or script? Check ~/scripts on that Mac.
• Is it a note? Check the Obsidian vault on the Mac where you wrote it.
• Is it a project? Check the T9 or the private GitHub repo.

That is enough to avoid the “I thought it was synced” panic.

Pick a source of truth per file type

The pattern behind all of this is simple: pick a single source of truth for each type of file, and stick to it.

• Tools and scripts: a local, non-synced folder like ~/scripts.
• Notes: local Obsidian vault per Mac, unless they belong in a more global system.
• Projects: the T9 SSD or a private GitHub repo.

Choose per type of file where the truth lives, instead of letting everything try to sync itself.