Stop Organizing Apps. Organize States.

The five-layer Mac stack I run with Notes, Finder, Reminders, Focus, Shortcuts, and macOS Tahoe’s Use Model action — no subscriptions, no new apps

At 9:14 AM this morning I caught myself being a human USB cable again. Copy the paragraph out of Safari. Paste it into Notes. Hunt for the screenshot in Downloads. Rename it. Ask an AI to summarize the thing I just read. Lose the summary. Open Calendar. Forget what the work block was even for.

I do this for a living — I test Mac and AI workflows so other builders don’t burn their mornings rebuilding context — and I still leak time in the gaps between apps. That gap is the real tax. Not the work. The switching.

Here’s the uncomfortable part. My Mac is not slow. The M-series chip is absurd. The leak isn’t hardware. It’s that almost everyone uses macOS like a prettier Windows: a drawer of separate apps you manually shuttle data between. And the fix for that has been sitting in the operating system the whole time — it just shipped as eight boring, disconnected apps instead of one product.

This article is the wiring. Five layers, six default apps, one new action that landed in macOS Tahoe, and the exact Shortcut recipe and scripts I run. No Notion. No paid productivity app. No subscription. By the end you’ll have a Mac that captures context before you lose it, compresses it locally, routes it to the right place, and can restart your brain in under sixty seconds.

Your Mac Isn’t Slow. Your Workflow Is Leaking.

When people say their Mac “feels slow,” they almost never mean the CPU. They mean one of five things:

• They can’t find the file.
• They can’t remember the decision.
• They can’t recover the context.
• They can’t restart the task quickly.
• They can’t tell which work actually mattered.

None of that shows up in Activity Monitor. CPU lives in Activity Monitor, disk lives in Storage settings, app time lives in Screen Time, meetings live in Calendar, tasks live in Reminders, files live in Finder. Every tool measures its own little world. Nobody measures the tax between them.

That tax is where the day disappears. I lost the better part of a year to it before I started measuring honestly: the first 20–25 minutes of every work session went to rebuilding the mental room — which file, which tab, which half-finished thought. Multiply that across context switches and the number gets ugly.

So I stopped asking “which app should I use?” and started asking one question instead:

What if the Mac automatically turned every important work moment into a searchable, tagged, summarized, scheduled object?

That sounds like a startup pitch. The strange thing is you can build a genuinely useful version of it with apps Apple already ships.

The Shift That Changes Everything: States, Not Apps

Most Mac setups are app-shaped. Writing app, calendar app, task app, browser, AI chat, file manager. That’s the wrong unit.

Real work doesn’t happen in apps. It happens in states. You’re researching. Drafting. Debugging. Recording. Deciding. Shipping. Recovering. The app is incidental. The state is the thing.

Once I reframed around states, the system designed itself. I call it the Anti-Waste Mac Stack, and it has exactly five layers:

Everyone already has these apps. The trick is making them behave like one system instead of eight. Let me take them one at a time, with the actual builds.

A confession before I do: my first version had ten Shortcuts and four custom Focus modes, and I abandoned nine of the Shortcuts inside a week. The system only stuck when I cut it down to one capture action and one compress action. Treat everything below as the version that survived deletion, not the version I started with.

Layer 1 — Capture: The Six-Field Object

The first rule of serious solo work: if the context isn’t captured, it doesn’t exist. Your brain isn’t a database. Your tabs aren’t a database. Your memory of “I saw that thing yesterday” is definitely not a database.

The Capture Layer has one job — when something useful appears, the Mac records it in a predictable shape. Not a perfect shape. A predictable one. Mine is six fields:

Date:
Source:
Project:
Why it matters:
Raw link / file:
Next action:

Six fields looks trivial. It isn’t. It creates a standard unit of work. A Safari article, a screenshot, a PDF, a meeting note, an AI response, a client message — all of them collapse into the same object. And once everything is the same object, the Mac can route it automatically. That’s the entire unlock, and the next two layers depend on it.

You don’t want to type six fields by hand every time, or you won’t do it. So this is the first Shortcut. It runs from the Share Sheet or the menu bar, takes whatever you’ve selected, and starts the object for you:

SHORTCUT: "Capture →"
Trigger: Share Sheet + menu bar
1. Receive  [Safari pages, Text, Images, PDFs]  from input
2. Get Current Date            → save as Date
3. Get URLs from Input         → save as Source (fallback: "manual")
4. (next: hand off to Compression — Layer 2)

That’s it for raw capture. The object exists. Now we make it small.

Layer 2 — Compression: One Action Does the Heavy Lifting

This is the part that got dramatically better in the last year, and it’s the part most “macOS tips” articles still describe vaguely. So let me be precise.

In macOS Tahoe, the Shortcuts app gained a single action called Use Model. You hand it a prompt and your Shortcut variables, and it routes the request to one of three places:

• On-Device — Apple’s local foundation model. Fastest, fully private, works with no network at all.
• Private Cloud Compute — Apple’s cloud model path for heavier requests, designed around Apple’s privacy architecture.
• ChatGPT / Extension Model — when you need a larger external model and don’t mind leaving Apple’s local-or-private path.

For a workflow engine, the under-discussed detail is not that Use Model can write text. It’s that you can pressure it into returning a predictable dictionary shape — project, summary, why it matters, next action — that the rest of the Shortcut can route. Not deterministic in the database sense; this is still a model. But structured enough for low-risk routing, because Apple's own docs note that a model's output can be parsed and fed into the next action. Federico Viticci's MacStories walkthrough is the best practical treatment I've seen of pushing the action toward structured returns, if you want to go deeper.

That reframes what AI is for. Most people reach for AI to generate. The far more valuable move, especially for builders and writers, is to use it to compress reality before you forget it. A 4,000-word article becomes six fields. A messy meeting becomes decisions and next actions. A Safari rabbit hole becomes one note. On-device, that summarization runs in a few seconds with zero network — which means it’s private and it works on a plane.

Here’s the compression step appended to the Capture shortcut. The prompt is doing the real work, so I’ve written it out in full:

SHORTCUT (continued): Compression step
5. Use Model
   Model: On-Device   (switch to Private Cloud Compute for long PDFs)
   Prompt:
     """
     You are a capture compressor. Read the input text and return a
     dictionary with EXACTLY these keys and nothing else:
       date          – today's date
       source        – the URL or "manual"
       project       – one of: [wowhow, writing, client, research, admin]
       why_it_matters – one sentence, max 20 words
       summary       – three bullet points, max 15 words each
       next_action   – an imperative task, or "" if none
     Return only the dictionary.
     """
   Input: [Shortcut Input + Date + Source variables]
   Return type: Dictionary
6. Get Dictionary Value  → pull each key into its own variable

Two things make this hold up in practice. First, pinning project to a fixed list keeps the model from inventing a new bucket every time, which would defeat routing. Second, asking for next_action to be "" when there's nothing to do is what lets Layer 3 branch cleanly instead of creating junk reminders. Small constraints, large payoff.

You will still glance at the output before it saves. The on-device model is fast and private, not infallible. Treat it like a sharp intern: brilliant at compression, occasionally confidently wrong, always worth a two-second check.

Layer 3 — Routing: Where Compressed Context Goes

This is the layer almost everyone skips. They save everything — and saving just creates storage. Routing creates memory.

After compression, the object goes to exactly one of four places, decided by what kind of thing it is:

• Notes gets knowledge. Anything useful-later: article summaries, product ideas, saved prompts, system designs, client insights.
• Reminders gets action. Anything that must be done: reply to a reader, test an app, submit to a publication, ship a banner.
• Calendar gets time. Anything that needs protected attention: a 90-minute writing block, a Friday publishing audit, a weekly cleanup.
• Finder gets evidence. Anything that’s a file: screenshots, PDFs, exports, receipts — but tagged by state, not topic (the next section is the whole system for this).

The Shortcut now branches on the schema. Because next_action is either a real task or an empty string, the logic is clean:

SHORTCUT (continued): Routing
7. Append to Note  "📥 Capture Log"
     Body: Date • Source • Why it matters • Summary
8. If  next_action  is not  ""
     → Add New Reminder
         Title: next_action
         List: project-specific Reminders list (Writing, Client, Research, Admin)
9. If  project  is  "writing"
     → Add Calendar Event "Writing block" — tomorrow 09:00, 90 min
10. Show Notification  "Captured → Notes" + (next_action ? "+ Reminder" : "")

If you use Apple Intelligence’s suggestions in Reminders, it can help sort tasks for you — but I keep the routing explicit, because automation should be boring and predictable. The moment it starts guessing where things go, I stop trusting it, and a system I don’t trust is a system I stop using.

This Shortcut takes shared content, runs it through macOS Tahoe’s Use Model action, extracts a structured response, pulls the next_action field, and automatically turns it into a Reminder if one exists.

The whole chain — select text, run shortcut, summarized object lands in Notes, task lands in Reminders, evidence gets tagged — is one keystroke. The version of me from a year ago did that in roughly six manual steps and lost the thread on at least two of them. Here’s the honest before/after, after a week of running it:

Workflow leak                        │  Before                   │  After
─────────────────────────────────────┼───────────────────────────┼───────────────────────
Save useful Safari research          │  3–5 minutes              │  One shortcut
Turn an article into an action item  │  Manual copy / paste      │  Auto-routed Reminder
Find supporting screenshots          │  Random Downloads search  │  EVIDENCE Smart Folder
Restart yesterday's work             │  15–25 minutes            │  Recovery Brief
Decide what to do next               │  Mental rebuild           │  One next move

These are not lab benchmarks. They’re my rough timing notes after using the stack for a week. But that delta, repeated forty times a day, is the leak closing.

Saving creates storage. Routing creates memory. Most people only ever do the first one.

The Brutal Rule: Every File Must Explain Why It Exists

Routing knowledge into Notes and action into Reminders is half the job. The other half is the files — and Finder is where most systems quietly rot. So here’s the rule I enforce: if a file can’t explain why it exists, it’s waste.

Files don’t get organized by topic. They get organized by decision status — one of four states:

• INBOX — unprocessed. Downloads, screenshots, random exports. Allowed to be messy, but only temporarily.
• ACTIVE — connected to current work. Drafts, design files, code notes.
• EVIDENCE — used to support a claim. Screenshots, receipts, benchmarks, logs.
• ARCHIVE — useful later, not needed now.

A screenshot about, say, Safari memory usage isn’t filed under “Safari.” It’s filed under whether it’s inbox, active, evidence, or archive. Once you know the state, you know what to do with it. Topic-organizing tells you what a file is about. State-organizing tells you what to do with it. Different game entirely.

You set the four as Finder tags (default feature), then let a Smart Folder surface what needs attention. To find everything still sitting in the inbox state, the built-in Spotlight CLI does it without any extra software:

# mdfind is Spotlight from Terminal — if Finder can search it, mdfind can query it, usually faster.
# Everything tagged INBOX, oldest first — your "to process" pile:
mdfind "kMDItemUserTags == 'INBOX'" | while read f; do
  echo "$(stat -f '%Sm' "$f")  ${f}"
done | sort

The shock is how much calmer Finder gets when files carry a decision state instead of a clever name. The mess is still allowed — it just has a half-life now. With Capture, Compression, and Routing in place, you now have a complete loop for incoming context. The last two layers are about your own state: what you see, and how you restart.

Layer 4 — Focus: The Mac Should Change Shape by State

Focus is the most underused power feature on the Mac, because everyone treats it as “hide notifications.” That’s the weakest possible use.

The strong use: Focus changes the shape of your Mac depending on the state of work. When I’m writing, I should not see the same Mac I see when I’m researching. When I’m debugging, I should not see the Mac I see when I’m doing admin. Focus becomes a state switch, and on Tahoe each mode can trigger a Shortcut automation when it turns on.

Focus mode  │  What's visible                                                                 │  What it triggers
────────────┼─────────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────
Writing     │  Notes, Safari Reader, the draft, the writing folder. No social, no analytics.  │  Opens the draft, starts a 90-min timer
Research    │  Safari, Notes, the research folder, screenshots, PDFs                          │  Opens the Capture shortcut in the menu bar
Shipping    │  The editor, the images folder, the publish checklist                           │  Opens the checklist note
Recovery    │  Yesterday's notes, open reminders, active drafts                               │  Runs the Recovery Brief (next section)

Most people lose the first twenty minutes of work rebuilding the mental room by hand. Focus lets the Mac rebuild the room for you, and the automation hook means the room assembles itself the moment you flip the switch.

Layer 5 — Recovery: The 60-Second Restart

This is the layer that changed everything for me, because real productivity doesn’t die during deep work. It dies before it — in the cold open. You sit down, you don’t know where to continue, so you “research” your way through messages, analytics, and YouTube until lunch.

The Recovery Layer kills that loop with one generated note every morning:

TODAY'S RECOVERY BRIEF
Yesterday's active project:
Last useful note:
Open actions:
Files touched:
One next move:

Not twenty tasks. One next move. The purpose isn’t to plan the day. It’s to remove the first decision, because the first decision is the most expensive one.

Here’s the actual AppleScript that builds it. It reads your incomplete reminders, grabs your shutdown marker, and assembles the brief into a fresh note. It runs entirely on default macOS — no third-party tools.

Read this before you run it. It only reads your incomplete Reminders and creates a new Note — it deletes nothing — but change the paths to your own, and run it once by hand before you schedule it.

-- recovery_brief.applescript
set briefDate to (current date)
set taskLines to ""

tell application "Reminders"
    set openTasks to (reminders whose completed is false)
    repeat with t in openTasks
        set taskLines to taskLines & "• " & (name of t) & linefeed
    end repeat
end tell

-- read the "I stopped here" line written at shutdown
set stopFile to (POSIX path of (path to home folder)) & "stopped_here.txt"
try
    set lastStop to (do shell script "cat " & quoted form of stopFile)
on error
    set lastStop to "(no marker from yesterday)"
end try

set briefBody to "TODAY'S RECOVERY BRIEF — " & (short date string of briefDate) & ¬
    linefeed & linefeed & "One next move:" & linefeed & lastStop & ¬
    linefeed & linefeed & "Open actions:" & linefeed & taskLines

tell application "Notes"
    tell default account
        -- if your notes live in a different folder, change "Notes" to its name
        make new note at folder "Notes" with properties {body:briefBody}
    end tell
end tell

Then you schedule it so it’s waiting before you sit down. macOS runs scheduled jobs with launchd. Save this plist to ~/Library/LaunchAgents/ and load it once:

<!-- ~/Library/LaunchAgents/com.local.recoverybrief.plist -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>Label</key>            <string>com.local.recoverybrief</string>
  <key>ProgramArguments</key>
  <array>
    <string>/usr/bin/osascript</string>
    <string>/Users/YOU/scripts/recovery_brief.applescript</string>
  </array>
  <key>StartCalendarInterval</key>
  <dict>
    <key>Hour</key>   <integer>6</integer>
    <key>Minute</key> <integer>30</integer>
  </dict>
</dict>
</plist>

# Load it (the classic command, still works on Tahoe):
launchctl load ~/Library/LaunchAgents/com.local.recoverybrief.plist

# If Tahoe complains, use the modern form instead:
launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.local.recoverybrief.plist

At 6:30 every morning, the brief is already written. I open the lid, read one line, and start. Cold lid to first real keystroke is under a minute. The brief depends on one tiny habit from the night before — the shutdown marker — which is the only piece of this whole stack you do by hand.

Tomorrow-you doesn’t need motivation. Tomorrow-you needs coordinates.

What to Ship by Sunday

Don’t build the whole stack at once; that’s how a productivity system quietly becomes procrastination. Build one layer a day. By Sunday you’ll have the whole thing running.

1. Make the six-field Notes template today. Date, Source, Project, Why it matters, Raw link, Next action. Use it for the next useful thing you find.
2. Create four Finder tags — INBOX, ACTIVE, EVIDENCE, ARCHIVE — and tag files by state, not topic.
3. Build the Capture → Shortcut with one Share Sheet trigger. Stop at raw capture; don't add AI yet.
4. Add the Use Model compression step with the dictionary prompt above. Run it On-Device first.
5. Wire the routing branch — Append to Note, and an If next_action that creates a Reminder.
6. Drop in recovery_brief.applescript and the launchd plist. Run it once by hand, then set it for 6:30. Write one "I stopped here" line tonight so tomorrow's brief has something to say.
7. On Sunday, audit the week: what did you capture, compress, route, and ship — and what did you repeat for no reason? That answer is next week’s upgrade.

Each step is one sitting. None of them needs anything you’d have to buy.

The Real Upgrade Was Never the Apps

I used to think a better Mac meant better apps. Now I think it means better handoffs: Safari to Notes, Notes to Reminders, Reminders to Calendar, Finder to evidence, evidence to the next draft. That loop is the product. Not the apps. The loop.

If you want to start today, do the smallest possible thing: open Notes, make the six-field template, and use it on one article you read this week. That’s the seed. It takes five minutes and it’s the part that makes everything else worth wiring.

This week, build the Capture → Shortcut and add the Use Model step. Run it On-Device so you feel how fast local compression actually is, then point it at three real things — an article, a meeting note, a long email. You'll know within an hour whether the dictionary is shaped right for how you work, because the wrong shape produces junk reminders and you'll feel it immediately.

Over the next month, the harder move is the one that compounds: let the Mac generate your Recovery Brief every morning and write one honest “I stopped here” line every night. Thirty days of that builds something no app can sell you — a machine that remembers the shape of your work. I write about these builds publicly, and the recovery loop is the single piece readers tell me actually stuck. You don’t need my version. You need a calm Sunday and a willingness to delete the nine Shortcuts that don’t earn their place.

The future isn’t AI that thinks for you. It’s an operating system that keeps the conditions around your thinking alive long enough for you to finish something. Your Mac already has the parts. All you were missing was the wiring.

🔗 Resources

Resource                                                            │  Link
────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
Use Apple Intelligence in Shortcuts (Apple Support)                 │  https://support.apple.com/guide/mac-help/mchl91750563/mac
macOS Tahoe 26 feature overview (Apple Newsroom)                    │  https://www.apple.com/newsroom/2025/06/macos-tahoe-26-makes-the-mac-more-capable-productive-and-intelligent-than-ever/
launchd scheduling reference (launchd.info)                         │  https://www.launchd.info/
The Use Model action, deeper walkthrough (MacStories — commentary)  │  https://www.macstories.net/

🏷️ Tags

macOS · Mac Productivity · Shortcuts · Apple Intelligence · Automation