The Inbox Had 28,880 Files

I opened 0. Inbox/ one evening and the file count stopped me cold. 28,880 files. Voice memos I’d dictated while driving and never transcribed. Email forwards I’d sent myself six months ago. Quick thoughts I’d jotted down and forgotten. 707 lines of stuff to actually process.

I had built a capture machine with no off-ramp.

This is a story about how I got that down to 49 lines a day — a 92% reduction — but the number isn’t the point. The point is what happened to my mornings once I stopped deciding what to work on while I was least equipped to decide.

Six Tasks, Written the Night Before

In 1918, an efficiency consultant named Ivy Lee handed Bethlehem Steel president Charles Schwab a method so simple Schwab later paid him $25,000 for it — about $400,000 in today’s money. Here’s the whole thing:

At the end of each workday, write down the six most important tasks for tomorrow.
Rank them in strict priority order.
The next day, start on task #1. Work on nothing else until it’s done.
Move to #2. Then #3. Keep going.
Whatever doesn’t get done rolls to tomorrow’s list.

I tried it. Then I kept trying it for six months.

The constraint is the mechanism. Six slots mean you have to say no to things. You can’t hide a “nice to have” at position #14 and pretend it counts. You look at 30 things competing for your attention and you pick six. The other 24 don’t make the cut. Tomorrow, maybe. Today, no.

The second mechanism is even more important: the decision happens at night. Evening-me has context. I know what actually happened today, what’s truly on fire, what deadline is closest. Morning-me has none of that. Morning-me will open email and let someone else’s urgency become my priority. Morning-me cannot be trusted with the decision.

So evening-me decides. Morning-me just executes.

This is harder than it sounds.

Your brain fights the sequence constantly. Task #4 looks more fun than task #1. A Slack message arrives and feels urgent. You tell yourself task #1 is “blocked” because you’re waiting on someone — and maybe it is, but usually you’re just avoiding the hard thing. The rule is simple: work on #1 until it’s done, then #2. No multitasking. No quick email checks. No “just let me handle this one thing real quick.”

Most days I finish four or five of the six. That’s actual progress — not checkbox theater on a 30-item list where you knock off the easy eight and avoid the two that matter.

The Evening Ritual

Every night, 15 to 20 minutes. Here’s what actually happens:

First, I look at what got done today. Not to feel guilty about what didn’t — to learn the pattern. If task #5 has rolled forward four days in a row, it’s either not actually important or it’s too big and needs to be broken down. Either way, staring at the pattern tells me something the individual day never could.

Then I scan my active projects. I open 1. Projects/ in Obsidian and look at each folder. What needs to move tomorrow? What’s blocked? What has a deadline breathing down its neck? This is where I catch the thing I forgot about — the follow-up I promised someone, the doc that’s due Friday.

I check my Areas for maintenance tasks. Areas are ongoing responsibilities — things that never end. Arcs Health operations needs daily attention. Biblical education reading happens weekly. Second brain cleanup, monthly. I pull in whatever area task is due.

Then I process the inbox. Not email inbox — my 0. Inbox/ in Obsidian, where every capture lands: voice memos, forwarded emails, quick notes, web clippings. Anything actionable becomes a task (maybe one of tomorrow’s six). Reference material gets filed into Resources. Junk gets archived. The goal is zero — every evening, everything has a home.

Finally, I rank. This is the hard part. Six tasks, numbered 1 through 6, in order of impact — not ease, not fun, not “what I feel like doing.” The task I least want to do often gets #1, because that’s exactly why it needs to be first. If I do nothing else tomorrow except task #1, the day still moved something that mattered.

Everything goes into a single file called Today.md:

# 2026-01-24

## Priority Tasks
1. [ ] Complete Nashville financial due diligence report
2. [ ] Draft Q1 2026 board memo (operational metrics)
3. [ ] Review behavioral health launch timeline with team
4. [ ] Process 50 inbox captures (Python automation)
5. [ ] Update TELOS with Q4 outcomes
6. [ ] Write second brain blog post

## Context
- Nashville deal deadline: Jan 31
- Board memo due: Feb 5
- Focus: Close deals, document systems

## Notes
- [captures throughout the day]

One file. One source of truth. When I wake up, I don’t check email, Slack, or my calendar. I open Today.md and start on task #1.

PARA: Where Everything Lives

The six-task system handles execution. But knowledge work generates more than six tasks a day — it generates notes, documents, emails, ideas, reference material. You need somewhere to put all of it, and that somewhere needs to make things findable when you actually need them.

Tiago Forte’s PARA methodology divides your entire digital life into four buckets:

Projects

A series of tasks with a goal and a deadline. “Launch behavioral health service.” “Close Nashville acquisition.” “Ship blog automation.” Projects are time-bound and have a clear finish line. When they’re done, they move to Archive.

Areas

Ongoing responsibilities with standards to maintain. “Arcs Health operations.” “Biblical education.” “Health and fitness.” “Second brain maintenance.” Areas never end — they’re life domains that need continuous attention. If something has no finish line, it’s an area, not a project.

Resources

Topics of interest, reference material, things you might use later. “QLA methodology notes.” “Python automation scripts.” “Healthcare regulations.” Not immediately actionable, but valuable when you need them.

The 92% Reduction: How the Automation Actually Works

The evening planning ritual was working, but inbox processing was the bottleneck. My 0. Inbox/ directory had ballooned to 28,880 files. Processing that manually would take forever. I needed automation.

I built it in two layers.

A Python script that uses pattern matching — no LLM calls, no network round-trips, just re and pathlib. It reads each capture, checks sender domain, subject keywords, and existing YAML frontmatter fields, then either archives it or promotes it into the right PARA folder. Marketing emails get archived immediately with no manual review. Operations emails get tagged for review and linked to the relevant Area. Project-related emails get linked to the active project and flagged for action.

A bash orchestration layer that groups inbox files by capture date, slices them into batches of about 50, and feeds each batch to the Python stage. Files are processed one at a time with path validation before any move operation — so the script can’t accidentally relocate the entire 0. Inbox/ directory.

Before automation: 707 lines of stuff to process daily, 2–3 hours of manual triage per week. After: 49 lines, 15–20 minutes per day. The automation doesn’t make decisions for me — it filters noise and surfaces signal. I still review everything marked important. I’m just not wading through marketing spam to find it.

Multi-Level Capture Architecture

Different kinds of capture need different levels of friction:

Level 1: Audio Capture. Voice memos while driving, walking, or thinking. These land in a Whisper transcription pipeline that converts speech to text with intelligent tagging:

# Whisper transcription + intelligent tagging
.scripts/transcription/process_audio.sh

Level 2: Quick Capture. Email forwards, web clippings, rapid notes. Straight to 0. Inbox/ with minimal metadata:

---
created: 2026-01-24T08:15:00Z
source: email
---

Subject: Nashville seller response
From: [email protected]
Date: 2026-01-24

[content]

Level 3: Daily Processing. The evening ritual triages everything. Actionable items become tasks. Reference material moves to Resources. Junk gets archived.

Level 4: Project/Area Integration. Important captures get linked to Projects or Areas and tagged with Substrate connections — data sources, claims, outcomes in my evidence base.

CODE: Capture → Organize → Distill → Express

The inbox automation fits into a larger workflow — CODE, inspired by Tiago Forte’s work:

Capture has to be nearly frictionless. If capturing something takes more than 10 seconds, you won’t do it consistently. Voice memos transcribed automatically. Emails forwarded to inbox. Web content clipped with minimal metadata. The goal: never lose an idea because the mechanism was too heavy.

Organize happens during evening planning. Everything moves from 0. Inbox/ into its PARA home. Inbox zero every evening.

Distill extracts the essence from important captures. Not every note needs it, but the ones that do get progressive summarization: highlight key paragraphs on first read, bold important sentences on second review, highlight keywords within those bold sentences, write a one-to-two-sentence summary at the top. This creates layers — quick review reads the summary, deeper review scans the highlights, full deep dive preserves the original.

Express is the payoff. Blog posts. Project documentation. Board memos. Code. Strategic decisions. A note that never gets used is just digital clutter with better branding.

Progressive Disclosure: Don’t Process Everything Up Front

One principle keeps the whole system sustainable: process information when you need it, at the level of detail you need it. I borrowed this from software engineering — it’s essentially lazy loading for knowledge.

the mechanism: lazy enrichment + automation pipeline give me the detail

The three-level schema is a lazy enrichment pattern: notes arrive as thin raw captures (Level 1), get promoted to structured PARA notes during triage (Level 2), and only reach full project context (Level 3) when the project is actually active. The key insight is that enrichment is deferred — you pay the cost only when the information becomes load-bearing.

The pipeline that makes this tractable at scale uses two layers:

Shell orchestration groups inbox files by capture date, slices them into batches of ~50, and feeds each batch to the Python stage. Critically, files are processed one at a time with path validation before any mv, so there’s no footgun that can relocate your entire 0. Inbox/ directory.

Python pattern-matching classifies each file with a small decision tree — sender domain, subject keywords, YAML frontmatter fields already present — and either archives it outright or writes a promoted Level-2 note into the appropriate PARA folder. No LLM call, no network round-trip; just re and pathlib.

Try it in any Obsidian vault with a single shell one-liner to measure your own promotion ratio:

# Count inbox files that already carry at least one PARA-shaped frontmatter key
grep -rl --include="*.md" \
  -e "^project:" -e "^area:" -e "^category:" \
  "0. Inbox/" | wc -l

A low count means your captures are still raw Level-1 — fertile ground for an evening-ritual triage pass or a 50-line classification script. A high count means your capture workflow is already doing the enrichment work for you.

Most notes — about 80% — need minimal processing: quick capture, filed in PARA, searchable if needed. About 20% deserve the full progressive summarization treatment. The system lets you distinguish between them instead of treating every scrap of text like a research paper.

Claude Code Reads My Second Brain

This isn’t just a static filing system. Claude Code has read-access to my entire Obsidian vault. When I’m working on a project, I can ask:

“What does my Substrate say about staffing optimization at Covenant?”

Claude searches 0. Foundation/Substrate/, finds the relevant claims and data sources, and synthesizes an answer grounded in my actual evidence base — not some generic advice from its training data.

The Substrate layer is my addition to PARA. It’s an evidence base that grounds decisions:

Problems (PR-00001, PR-00002…): What’s broken?
Claims (CL-00001, CL-00002…): What do I believe is true?
Data Sources (DS-00001, DS-00002…): What evidence supports this?
Solutions (SO-00001, SO-00002…): What are we trying?
Outcomes (OUT-00001, OUT-00002…): What happened?

Every strategic decision links back to the Substrate. This prevents me from making the same mistake twice and builds institutional memory — the kind that usually evaporates when someone leaves a company. I can also delegate batch processing to Claude Code directly. “Process the 50 inbox captures from 2026-01-23. Archive marketing emails, create PARA notes for Arcs-related items, flag anything requiring my attention.” Claude runs the automation, reviews each capture, and returns a summary:

Processed 50 captures:
- 32 marketing emails → Archived
- 12 operations updates → Filed in Areas
- 4 project updates → Linked to active projects
- 2 requiring your review (flagged)

This is the real shape of the collaboration: the AI handles mechanical processing, I focus on judgment and strategy.

Wrong Turns I Made Along the Way

I spent months doing the opposite of what I’m describing here.

At one point I was running five separate systems: Jira for work tasks, Todoist for personal todos, Obsidian for notes, Google Calendar for time blocking, and email for follow-ups. Context switching between five places was killing my actual output. Worse, I’d spend mental energy deciding where to put a task instead of just doing it.

I’ve watched brilliant engineers spend hours configuring Notion databases, building elaborate Obsidian plugins, and color-coding their calendars — all while the actual work sat untouched. I was one of them. The trap isn’t the tools. The trap is confusing organizing work with doing work. Every minute spent tweaking a task management system is a minute not spent writing code, solving problems, or creating value.

The inbox bankruptcy moment — staring at 28,880 files and realizing I’d built a capture machine with no off-ramp — that’s what forced the redesign. I’d optimized for input and forgotten about throughput.

How to Build This Yourself

Phase 1: PARA Foundation (Week 1)

Create four top-level folders: 1. Projects/, 2. Areas/, 3. Resources/, 4. Archive/. Then inventory everything you’re working on. Has a deadline and outcome? Project. Ongoing responsibility? Area. Reference material? Resource. Move existing notes into the structure. Don’t obsess over perfection — you’ll refine as you use it.

Phase 2: Daily 6-Task System (Week 2)

Tonight, before bed, write tomorrow’s six tasks in priority order in a simple Today.md file. Tomorrow morning, start with task #1 and work sequentially. Notice when your brain tries to cheat — and it will. “This email is urgent.” “Task #3 looks more fun.” “I’m not in the mood for #1 right now.” Ignore all of it. Yesterday-you had context. Trust the ranking.

Phase 3: Inbox Processing (Week 3–4)

Create 0. Inbox/. Capture everything there. Process it during evening planning. If you’re technical, build simple automation — start with the obvious patterns first. A bash one-liner that archives marketing emails is better than a 500-line pipeline you never finish.

Phase 4: Substrate Evidence Base (Ongoing)

This is advanced — only needed if you’re making high-stakes decisions or building institutional memory. Create Problems/, Solutions/, Outcomes/. Link projects and decisions to these evidence-based entries.

Common Ways This Falls Apart

Organizing instead of working. You spend more time filing notes than doing actual work. Fix: set a timer. Inbox processing gets 20 minutes max per day. If it takes longer, your capture process is too heavy or your automation is missing.

Perfect categories. You agonize over whether something is a Project or an Area. Fix: use the time-based distinction. Has a deadline? Project. Ongoing? Area. When in doubt, search works better than perfect filing anyway.

Task list bloat. Your “six” tasks expand to ten, then fifteen. Fix: enforce the constraint ruthlessly. If seven things are important, rank them 1–7 and put only 1–6 in today’s list. Number 7 goes on tomorrow’s.

Inbox abandonment. Thousands of unprocessed files and you’ve given up. Fix: declare inbox bankruptcy. Move everything older than 30 days to Archive. Start fresh. Unprocessed old captures won’t magically become important.

Skipping evening planning. You wake up without a plan and waste morning hours deciding. Fix: make it non-negotiable. It’s 20 minutes that saves two hours the next morning. Block it on your calendar if that’s what it takes.

The System Serves You

The 6-Task System works because it removes decisions from the moment when willpower is lowest. Morning-you is tired, distractible, and drawn to the dopamine of easy wins. Morning-you will pick email over deep work every time. Evening-you has context and makes better choices.

The system is a commitment device — you’re making a promise to tomorrow-you about what matters, and tomorrow-you honors it by executing sequentially. Better decisions at night, better execution in the morning, better outcomes by the end of the week, better learning in the evening review. Repeat. Watch the flywheel spin.

I’ve been running this for six months. The specifics will evolve — yours should too. Maybe you need seven tasks instead of six. Maybe your evening ritual is 30 minutes instead of 20. Maybe you organize by project stage instead of PARA categories. That’s fine. The principles stay constant: constraint breeds clarity, sequential execution eliminates decision fatigue, evening planning removes morning friction, and automation eliminates mechanical work.

Start simple. Tonight, write six tasks for tomorrow. Tomorrow, work on them sequentially. Repeat.

Everything else — PARA, automation, Substrate — can come later.

Your most productive days aren’t the ones where you checked the most boxes. They’re the ones where you moved your most important work forward. Six tasks. Strict priority order. Sequential execution.

That’s the system.