The Tree That Grows Toward Your Life Goal
Most goal-setting advice is broken. It tells you to dream big, then immediately asks: “What’s your next action?” The gap between “become a recognized AI infrastructure expert” and “write a blog post” is so vast that you either freeze or start randomly doing things that feel productive.
I’ve been experimenting with a different approach: treat your goals like a tree, and only work on branches you can actually reach.
The Problem With Traditional Goal Setting
You set a big goal. Maybe it’s “build a successful consulting business” or “master distributed systems.” Then what?
Option A: You break it down into quarterly milestones. But those milestones are still too big. You stare at them and feel overwhelmed.
Option B: You jump straight to tasks. “Send 10 cold emails today.” But why? Does this actually connect to the big goal? Who knows. You’re just doing things.
The gap between vision and action is where goals go to die.
The Tree System
Here’s what works better: recursive decomposition until you hit something you can do right now.
Start with your life goal. One branch. Then ask: “What sub-goals would get me there?”
For each sub-goal, ask again: “What sub-goals would get me there?”
Keep going until you hit a branch that ends in something you can do today. Ideally right now.
Then do it. Mark it complete. Watch that branch grow upward toward the higher goals.
Example: The Consulting Business Tree
Life Goal: Run a thriving AI infrastructure consulting business
├── Sub-goal: Build reputation as expert
│ ├── Sub-goal: Publish thought leadership
│ │ ├── Sub-goal: Write 12 blog posts this quarter
│ │ │ └── Task: Write post about goal systems [DO THIS NOW]
│ │ └── Sub-goal: Speak at 2 conferences
│ │ └── Sub-goal: Submit 5 CFP proposals
│ │ └── Task: Research upcoming AI conferences [DO THIS NOW]
│ └── Sub-goal: Demonstrate expertise publicly
│ └── Sub-goal: Share technical insights weekly
│ └── Task: Post architecture diagram on LinkedIn [DO THIS NOW]
└── Sub-goal: Generate consistent revenue
├── Sub-goal: Build pipeline of qualified leads
│ ├── Sub-goal: Get 3 referrals from past clients
│ │ └── Task: Email previous client about coffee chat [DO THIS NOW]
│ └── Sub-goal: Establish presence in target market
│ └── Task: Join AI infrastructure Slack community [DO THIS NOW]
└── Sub-goal: Improve conversion rate
└── Sub-goal: Refine positioning
└── Task: Update homepage headline [DO THIS NOW]
Notice: every branch eventually ends in something concrete. Something you could do in the next hour.
Why This Works
1. No dead-end planning. You don’t create goals that float in space. Every sub-goal exists because it feeds into something higher. Every task exists because it grows a branch.
2. You always know what to do next. Just scan the tree for the lowest actionable branches. Do one. Watch it bubble up.
3. Motivation from compound progress. When you complete a low-level task, you’re not just checking a box. You’re literally growing multiple branches at once. That blog post? It feeds “publish thought leadership” AND “build reputation” AND your life goal. Three levels of progress from one action.
4. The big picture stays visible. You’re not lost in a task list. You can always zoom out and see how today’s work connects to the top of the tree.
5. Natural prioritization. Some branches have more actionable tasks than others. That’s fine. Work on what’s ready. The tree shows you where you’re blocked (branches with no actionable tasks yet) versus where you have momentum.
The Time is Always Now
Here’s the thing I keep learning: you can’t get caught up in time.
No deadlines. No “by Q2 2026.” No “in three months I’ll…”
The time is always now. The only question is: what branch can I grow right now?
Traditional planning wants you to spread tasks across a calendar. “I’ll do this in January, that in March.” But January never comes. There’s only ever this moment.
So the tree system doesn’t track time. It tracks readiness.
Is this task ready to do now? Do it now. Is this goal not decomposed enough? Decompose it now. Is this branch blocked? Work a different branch now.
The tree grows in the present moment. Always.
The Anti-Vision Paradox
This might sound like detailed planning. It’s not.
You’re not predicting the future. You’re not committing to a specific path. You’re just saying: “If I want to get there, I probably need to go through here.”
And the magic is: you only plan as deep as you need to find something doable.
If a branch isn’t ready to break down further, leave it. Come back when you’ve grown the other branches and gained new information.
The tree evolves. Branches get pruned. New branches appear. But you’re always working on something that’s both:
- Immediately actionable
- Connected to your highest goals
The Implementation: Structured Markdown
I’m implementing this with the simplest possible system: folders and markdown files.
Each goal is a folder. Each sub-goal is either:
- Another folder (if it needs more decomposition)
- A markdown file (if it’s a leaf node with actionable tasks)
goals/
└── consulting-business/
├── build-reputation/
│ ├── publish-thought-leadership/
│ │ ├── blog-posts.md
│ │ └── conference-talks.md
│ └── demonstrate-expertise.md
└── generate-revenue/
├── build-pipeline.md
└── improve-conversion.md
Inside each markdown file? Just a list of tasks with checkboxes:
# Blog Posts
- [x] Write post about goal systems
- [ ] Write post about Restic performance
- [ ] Write post about AI infrastructure patterns
That’s it. No app. No database. No sync. No dates. Just files you can grep, find, and edit with vim.
The file system is the tree. The folder structure is the hierarchy. Your tools already understand it.
Why Markdown Files?
It’s portable. Move it anywhere. Edit it anywhere. No vendor lock-in.
It’s greppable. Want to see all your actionable tasks? grep -r "\[ \]" goals/ Done.
It’s git-friendly. Track your progress over time. See which branches grew. Diff your trees.
It’s simple. No learning curve. No configuration. No “productivity system setup” that takes a week.
It matches how you think. Folders contain things. Files list things. Your brain already knows this pattern.
It’s timeless. No calendar integration. No overdue tasks turning red. Just: ready or not ready. Now or not now.
And here’s the beautiful part: the file system enforces the tree structure. You can’t create a floating task. It has to live in a file. Which lives in a folder. Which connects to your top-level goal.
The structure is the system.
Building Your Own Tree
Start simple:
Pick one life goal. Create a folder for it.
Ask: “What 2-4 sub-goals would get me there?” Create folders or markdown files.
Keep decomposing. When a goal needs more breakdown, make it a folder. When it’s ready for tasks, make it a markdown file.
Do the lowest hanging fruit. Find an unchecked box. Do it now. Check it off.
Watch the branches grow. When all tasks in a file are done, that sub-goal is complete. Mark it. Move up the tree.
Repeat. Keep working the branches. Keep decomposing when you get stuck. Keep pruning dead wood.
No dates. No timelines. Just: what’s ready now?
Why I’m Switching to This
I’ve tried the big vision approach (gets vague). I’ve tried the daily wins approach (gets disconnected). I’ve tried quarterly OKRs (gets bureaucratic). I’ve tried productivity apps (gets complicated). I’ve tried calendar-based planning (gets caught up in time).
The tree system gives me both:
- The clarity of “just do this one thing now”
- The confidence that this one thing actually matters
And by using plain markdown files, I get:
- Zero friction to update
- Total control over structure
- Tools I already know
- A system that will outlive any app
- Freedom from time anxiety
Every action grows multiple branches. Every branch connects to the top. No wasted effort. No floating tasks. No imaginary futures.
Just a tree, growing steadily toward the goal, one moment at a time.
What’s your life goal? Can you decompose it until you hit something you can do right now?
Create a folder. Add a markdown file. Start checking boxes.
The time is always now.
The tree doesn’t lie.