The 6-Task System: How I Manage Knowledge Work with PARA + Ivy Lee Method

The best productivity system is the one you’ll actually use. After years of experimenting with todo apps, kanban boards, and elaborate task managers, I found something that works: a hybrid of Tiago Forte’s PARA methodology and the century-old Ivy Lee Method. The result is a system that reduced my inbox from 707 lines to 49 (92% reduction), eliminated decision fatigue, and lets me focus on deep work.

The Paradox of Productivity Tools

Here’s the uncomfortable truth about productivity systems: most of them make you less productive. I’ve watched brilliant engineers spend hours configuring Notion databases, building elaborate Obsidian plugins, and color-coding their calendars — all while their actual work sits untouched.

The problem isn’t the tools. It’s that we’ve confused organizing work with doing work. Every minute spent tweaking your task management system is a minute not spent writing code, solving problems, or creating value.

I fell into this trap myself. At one point, I was using:

Jira for work tasks
Todoist for personal todos
Obsidian for notes
Google Calendar for time blocking
Email for follow-ups

Context switching between five systems was killing my productivity. Worse, I’d spend time deciding where to put a task instead of just doing it.

Why 6 Tasks Beats Infinite Todo Lists

In 1918, efficiency consultant Ivy Lee gave Bethlehem Steel president Charles Schwab a productivity method so effective that Schwab paid him $25,000 for it (equivalent to $400,000 today). The method was simple:

At the end of each workday, write down the six most important tasks for tomorrow
Prioritize them in order of importance
The next day, work on task #1 until it’s complete
Move to task #2, then #3, and so on
At day’s end, move unfinished tasks to tomorrow’s list

Why does this work? Three reasons:

Constraint breeds clarity. When you can only choose six tasks, you’re forced to distinguish between “important” and “merely urgent.” You can’t hide from priorities.

Sequential execution eliminates decision fatigue. You know exactly what to work on next. No debating whether to tackle email or that design doc. The decision was made yesterday.

Evening planning removes morning friction. Your most valuable morning hours aren’t wasted on planning — you wake up knowing exactly what needs to happen.

I’ve been using this method for six months. The constraint of six tasks transformed how I think about my day. Instead of a 30-item list that induces anxiety, I have six clear objectives. Most days, I complete 4-5 of them. That’s actual progress, not checkbox theater.

PARA as Organizational Backbone

The Ivy Lee Method handles execution, but knowledge work requires more than a daily task list. You need a system for organizing information — the notes, documents, emails, and ideas that feed your work.

That’s where Tiago Forte’s PARA methodology comes in. PARA divides your entire digital life into four categories:

Projects

Definition: A series of tasks with a goal and a deadline. Examples: “Launch behavioral health service,” “Close Nashville acquisition,” “Ship blog automation”

Projects are time-bound and actionable. They have clear outcomes. When a project is complete, it moves to Archive.

Areas

Definition: Ongoing responsibilities with standards to maintain. Examples: “Arcs Health operations,” “Biblical education,” “Health & fitness,” “Second brain maintenance”

Areas never end. They’re the life domains that require continuous attention. The distinction between projects and areas is critical: if it’s never-ending, it’s an area, not a project.

Resources

Definition: Topics of interest, reference material, knowledge base. Examples: “QLA methodology notes,” “Python automation scripts,” “Healthcare regulations,” “Leadership frameworks”

Resources are knowledge you might use later. They’re not immediately actionable, but they’re valuable for reference and learning.

The Time-Based Distinction

The genius of PARA is that it’s time-based, not category-based. Traditional organization systems use categories like “Work,” “Personal,” “Health” — but those categories don’t tell you what to do next.

PARA organizes by when you need the information:

Projects: Need it now (active work with deadlines)
Areas: Need it regularly (ongoing maintenance)
Resources: Might need it eventually (reference material)
Archive: Don’t need it anymore (historical record)

This temporal structure aligns perfectly with how knowledge work actually happens. When I’m working on a project, I don’t want to wade through my entire knowledge base — I want exactly the resources relevant to this deadline-driven work.

My Second Brain Structure

Here’s how I’ve implemented PARA in Obsidian:

0. Foundation/          # Identity, strategy, frameworks
   ├── TELOS.md        # Personal mission, goals, metrics
   └── Substrate/      # Evidence base (problems, solutions, outcomes)

0. Inbox/              # Capture point (~29,000 items auto-processed)

1. Projects/           # Active projects with deadlines
   ├── Nashville Acquisition/
   ├── Behavioral Health Launch/
   └── Blog Automation/

2. Areas/              # Ongoing responsibilities
   ├── Arcs Health/
   ├── Biblical Education/
   ├── Health/
   └── Second Brain/

3. Resources/          # Reference and learning
   ├── QLA Methodology/
   ├── Python Scripts/
   └── Healthcare Industry/

4. Archive/            # Completed projects
   ├── 2025-Q3-Board-Deck/
   └── Covenant-Acquisition/

The Foundation layer is my addition to PARA — it’s where my identity, mission, and strategic frameworks live. This is the “why” that informs all the work below it.

The Evening Ritual: Planning Tomorrow Today

Every evening, I spend 15-20 minutes planning the next day’s six tasks. This isn’t busywork — it’s strategic thinking at the lowest-friction moment.

Here’s the process:

1. Review Today’s Outcomes

What got done? What didn’t? Why? This isn’t about guilt — it’s about learning patterns. If task #5 keeps rolling forward, maybe it’s not actually important.

2. Scan Active Projects

I open 1. Projects/ and review each active project folder. What needs to move forward tomorrow? What’s blocking progress? What has the nearest deadline?

3. Check Areas for Maintenance

Areas require ongoing attention. Daily: Arcs Health operations. Weekly: Biblical education reading. Monthly: Second brain cleanup. I schedule the appropriate area tasks.

4. Process Inbox Zero (The Real Zero)

I don’t mean email inbox zero — I mean 0. Inbox/ zero. This is where all captures land: voice memos, email forwards, quick notes. I triage everything:

Actionable → Becomes a task or project
Reference → Goes to Resources
Maybe → Tagged for future review
Junk → Archived

5. Prioritize in Strict Order

This is the hard part. I write six tasks, numbered 1-6, in strict priority order. Not by ease. Not by fun. By impact.

The most important task gets #1. That’s the task that, if I do nothing else tomorrow, will have moved the needle. Often it’s the task I least want to do — which is exactly why it needs to be first.

6. Write in Today.md

Everything goes in a single file: Today.md. This is my single source of truth. Format:

# 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]

This takes 15-20 minutes. It’s an investment that saves hours the next morning.

Morning Execution: Sequential, No Replanning

When I wake up, I don’t check email. I don’t scan Slack. I don’t review my calendar. I open Today.md and start on task #1.

The rule is simple: Work on task #1 until it’s complete, then move to task #2.

No multitasking. No “quick” email checks. No deciding what feels right in the moment. The decision was made last night when I had context. Morning-me is an execution machine.

This is harder than it sounds. Your brain will fight you:

“But this email just came in and it’s urgent!”
“Task #3 looks more fun, let me just—”
“I’m not in the mood for task #1 right now.”

Ignore all of it. The priority order was set by yesterday-you, who had full context. Trust the system.

What If Task #1 Is Blocked?

If you genuinely can’t make progress on task #1 (waiting for someone else, missing information), move to task #2. But be honest about whether it’s truly blocked or whether you’re just avoiding hard work.

Most “blocks” are excuses. If task #1 is truly blocked, your evening planning failed — you should have seen that coming and prioritized differently.

What About Interruptions?

Real interruptions are rare. Most “urgent” things can wait 2-4 hours. I batch all communication:

Email: Checked at 11am and 4pm
Slack: Checked at 10am, 1pm, 4pm
Calls: Scheduled in afternoon blocks

If something is genuinely on fire (clinic emergency, deal falling through), you’ll know. Everything else can wait until you’ve made progress on your priorities.

The 92% Inbox Reduction: Automation Case Study

The evening planning ritual works, but there’s a bottleneck: inbox processing. At one point, my 0. Inbox/ directory had 28,880 files — email captures, voice notes, quick thoughts. Processing that manually would take forever.

So I built automation. Here’s the system:

Multi-Level Capture Architecture

Knowledge work requires capturing information at different levels of friction:

Level 1: Audio Capture Voice memos while driving, walking, or thinking. These land in a transcription pipeline:

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

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

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

Subject: Nashville seller response
From: seller@example.com
Date: 2026-01-24

[content]

Level 3: Daily Processing 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).

The Python Automation Pipeline

I wrote a Python script that processes inbox captures in batches:

# .scripts/inbox/process_capture.py
# - Extracts metadata (subject, sender, date)
# - Categorizes by content (marketing, operations, personal)
# - Archives junk automatically
# - Creates PARA notes for important items
# - Links to Substrate evidence base

The script uses pattern matching and keyword detection:

Marketing emails → Archived immediately (no manual review)
Operations emails → Tagged for review, linked to relevant Area
Project emails → Linked to active project, flagged for action
Personal → Triaged based on sender and content

The Results

Before automation:

707 lines in daily inbox processing
2-3 hours of manual triage per week
High friction = captures piling up unprocessed

After automation:

49 lines in daily inbox processing (92% reduction)
15-20 minutes of review per day
Low friction = inbox stays current

The automation doesn’t make decisions for me — it filters noise and surfaces signal. I still review everything marked “important,” but I’m not wading through marketing spam.

The Bash Orchestration Layer

A shell script orchestrates the daily automation:

# .scripts/process_inbox_with_codex.sh
# 1. Collects unique capture dates from inbox
# 2. Batches files by date (50 per batch)
# 3. Processes each batch with Python pipeline
# 4. Safety checks (never moves entire inbox)
# 5. Outputs summary for review

Critical safety feature: The script has multiple guards to prevent accidentally moving the entire 0. Inbox/ directory. It only processes specific files, one at a time.

CODE Workflow: Capture → Organize → Distill → Express

The inbox automation is part of a larger workflow I call CODE (inspired by Tiago Forte’s work):

Capture

Collect information with minimum friction. If it takes more than 10 seconds to capture something, you won’t do it consistently.

Voice memos → Transcribed automatically
Emails → Forwarded to inbox
Web content → Clipped with minimal metadata
Quick thoughts → Rapid note in Obsidian

Goal: Never lose an idea because the capture mechanism was too heavy.

Organize

Move captures from 0. Inbox/ into PARA structure. This happens during evening planning.

Actionable → Becomes a task (maybe one of tomorrow’s six)
Project-related → Filed in 1. Projects/[project-name]/
Reference → Filed in 3. Resources/[topic]/
Maintenance → Linked to appropriate Area
Junk → Archived (but preserved)

Goal: Inbox zero every evening. Everything has a home.

Distill

Extract the essence from captured information. Not every note needs distillation, but important ones do.

I use progressive summarization (another Tiago Forte technique):

Highlight key paragraphs on first read
Bold important sentences on second review
Highlight keywords in bold sentences
Write 1-2 sentence summary at top of note
Express in own words when using the knowledge

This creates layers of detail. Quick review? Read the summary. Need more? Scan the highlights. Deep dive? Full note is preserved.

Goal: Find information fast when you need it.

Express

Transform knowledge into output. This is the payoff for all the capture, organization, and distillation.

Blog posts (like this one)
Project documentation
Board memos
Code implementations
Strategic decisions

Expression is how knowledge becomes valuable. A note that never gets used is just digital clutter.

Goal: Create value from captured knowledge.

Progressive Disclosure and Lazy Loading

One principle that makes this system sustainable: progressive disclosure. Not everything needs the same level of detail.

Lazy Loading Pattern

I borrowed this concept from software engineering. Instead of processing everything upfront, I process information when I need it, at the level of detail I need.

Example: Email Capture

Level 1 (Immediate):

---
source: email
date: 2026-01-24
---
Subject: Nashville seller response
From: seller@example.com
[full email text]

Level 2 (When triaging):

---
source: email
date: 2026-01-24
category: operations
area: arcs-acquisitions
---
# Nashville seller response
- Seller agreed to $2.8M valuation
- Due diligence deadline: Jan 31
- Next: Schedule site visit

Level 3 (When working on project):

---
project: nashville-acquisition
status: active
next_action: Schedule site visit
---
# Nashville Seller Agreement

## Context
Seller (Dr. Johnson) agreed to $2.8M valuation after initial ask of $3.2M.

## Next Steps
- [ ] Schedule site visit (week of Feb 3)
- [ ] Complete financial DD report by Jan 31
- [ ] Draft LOI for board review

## Substrate Links
- [[PR-00007—Deal_Closing_Bottleneck]]
- [[SO-00018—Early_Deal_Disqualification_Framework]]

Each level adds detail only when needed. This prevents front-loading effort on information that might not matter.

The 80/20 of Note-Taking

80% of notes need minimal processing:

Quick capture
Filed in PARA
Searchable if needed later

20% of notes deserve deep processing:

Progressive summarization
Substrate linking
Actionable extraction

The system lets you distinguish between them. Not everything deserves equal attention.

Integration with AI Tools: Claude Code and Second Brain

My second brain isn’t static — it’s my thinking partner, powered by Claude Code.

How Claude Code Accesses My Knowledge

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 relevant claims and data sources, and synthesizes an answer grounded in my evidence base.

This turns my second brain into an external memory system that an AI can query. I’m not just storing knowledge — I’m building a knowledge graph that AI can reason over.

The Substrate Layer

The Substrate is my addition to PARA — it’s an evidence base that grounds my decision-making:

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 mistakes twice and builds institutional memory.

Example: Inbox Processing with Claude

I can delegate batch inbox processing to Claude Code:

“Process the 50 inbox captures from 2026-01-23. Archive marketing emails, create PARA notes for Arcs-related items, and flag anything requiring my attention.”

Claude runs the Python automation, reviews each capture, and generates 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 future of knowledge work: human-AI collaboration where the AI handles mechanical processing and the human focuses on judgment and strategy.

Complete Implementation Guide

Want to build this system yourself? Here’s the step-by-step:

Phase 1: PARA Foundation (Week 1)

Day 1-2: Structure Setup Create four top-level folders:

1. Projects/
2. Areas/
3. Resources/
4. Archive/

Day 3-4: Inventory Your Work List everything you’re working on. Distinguish:

Has a deadline and outcome? → Project
Ongoing responsibility? → Area
Reference material? → Resource

Day 5-7: Initial Organization Move existing notes into PARA structure. Don’t obsess over perfection — you’ll refine as you use the system.

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

Day 1: Evening Planning Tonight, before bed, write tomorrow’s six tasks in priority order. Use a simple Today.md file.

Day 2-7: Execution Practice Each morning, start with task #1. Work sequentially. Notice when your brain tries to cheat the system.

Phase 3: Inbox Processing (Week 3-4)

Week 3: Manual Triage Create 0. Inbox/ folder. Capture everything there. Process it during evening planning using CODE workflow.

Week 4: Automation If you’re technical, build simple automation:

# Quick triage script
for file in 0.\ Inbox/*.md; do
  if grep -q "marketing" "$file"; then
    mv "$file" "4. Archive/Marketing/"
  fi
done

Start simple. Automate the obvious patterns first.

Phase 4: Substrate Evidence Base (Ongoing)

This is advanced — only needed if you’re making high-stakes decisions or building institutional memory.

Create:

Problems/ - What’s broken?
Solutions/ - What are we trying?
Outcomes/ - What happened?

Link your projects and decisions to these evidence-based entries.

Templates and Tools

Today.md Template

# [Date]

## Priority Tasks
1. [ ] [Most important task]
2. [ ] [Second priority]
3. [ ] [Third priority]
4. [ ] [Fourth priority]
5. [ ] [Fifth priority]
6. [ ] [Sixth priority]

## Context
- Key deadline: [date]
- Focus theme: [one word]
- Meeting: [if any]

## Notes
[Captures throughout day]

## Evening Review
- Completed: [count]
- Rolled forward: [which tasks and why]
- Tomorrow's theme: [one word]

Project Template

---
status: active
start_date: YYYY-MM-DD
target_date: YYYY-MM-DD
area: [which area this belongs to]
---

# [Project Name]

## Goal
[What success looks like - one sentence]

## Why Now
[Why this matters and why it's time-bound]

## Success Metrics
- [ ] [Concrete outcome 1]
- [ ] [Concrete outcome 2]
- [ ] [Concrete outcome 3]

## Next Actions
- [ ] [Immediate next step]

## Resources
- [[Link to relevant resources]]

## Log
- YYYY-MM-DD: [Progress note]

Area Template

---
type: area
standard: [What "good" looks like]
review_frequency: [weekly/monthly]
---

# [Area Name]

## Purpose
[Why this area exists]

## Standards
- [Standard 1]
- [Standard 2]

## Current Projects
- [[Project 1]]
- [[Project 2]]

## Maintenance Tasks
- [ ] [Recurring task 1]
- [ ] [Recurring task 2]

## Resources
- [[Relevant resources]]

Common Pitfalls and How to Avoid Them

Pitfall 1: Organizing Instead of Working

Symptom: You spend more time organizing notes than doing actual work.

Fix: Set a timer. Inbox processing gets 20 minutes per day, maximum. If it takes longer, your capture process is too heavy or your automation is missing.

Pitfall 2: Perfect Categories

Symptom: You agonize over whether something is a Project or an Area, or which folder it belongs in.

Fix: Use the time-based distinction. Has a deadline? Project. Ongoing? Area. When in doubt, search works better than perfect filing anyway.

Pitfall 3: Task List Bloat

Symptom: Your “six” tasks expand to 10, then 15, then 20.

Fix: Enforce the constraint ruthlessly. If seven things are important, rank them 1-7 and only put 1-6 in today’s list. Task #7 goes on tomorrow’s list.

Pitfall 4: Not Processing Inbox

Symptom: Your 0. Inbox/ has thousands of 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.

Pitfall 5: Skipping Evening Planning

Symptom: You wake up without a plan and waste morning hours deciding what to work on.

Fix: Make evening planning non-negotiable. It’s 20 minutes that saves 2 hours the next day. Block it on your calendar if needed.

The Philosophy: Systems Over Willpower

The 6-Task System works because it removes decisions from the moment when willpower is lowest.

Morning-you is tired, distracted, and susceptible to the dopamine hit of easy wins. Morning-you will choose email over deep work every time.

Evening-you has context. You know what happened today, what’s coming tomorrow, what really matters. Evening-you makes better decisions.

The system is a commitment device. You’re making a promise to tomorrow-you about what matters. Then tomorrow-you honors that commitment by executing sequentially.

This is how you compound productivity:

Better decisions (evening planning)
Better execution (sequential focus)
Better outcomes (priorities actually completed)
Better learning (evening review)

Repeat daily. Watch the flywheel spin.

Conclusion: The System That Adapts

I’ve been using this system for six months. It’s transformed how I work. But the specifics will evolve — and yours should too.

The principles stay constant:

Constraint breeds clarity (six tasks, not infinite)
Sequential execution (finish one before starting another)
Evening planning (decide with context, execute with focus)
PARA organization (time-based, not category-based)
Progressive disclosure (process information at the level you need it)
Automation (eliminate mechanical work)

The implementation flexes. Maybe you need seven tasks, not six. Maybe your evening ritual is 30 minutes, not 20. Maybe you organize by project stage instead of PARA categories.

That’s fine. The system serves you — you don’t serve the system.

Start simple:

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

Everything else — PARA, automation, Substrate — can come later. The 6-Task System is the foundation. Build from there.

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.