G’day!
Most notes systems collapse in the gap between capture and creation.
Layered Thinking Notes (LTN) is how I bridge that gap.
Last week, we explored why most systems fade: not because of missing features, but because they’re too costly to return to.
This week, I want to show you how I use LTN in practice. Even if you never touch my template, the principles behind it are simple enough to use in any setup.
At its core, LTN has three layers:
Capture in my Commonplace journal
Processing where raw entries are clarified and connected
Thinking Notes where ideas are developed into insights worth keeping
Projects sit outside of LTN. They’re where those Thinking Notes are pulled into real creative output - newsletters, Threads, or products.
Here’s what that looks like in practice.
This issue began as a line in my Commonplace journal:
“Show how LTN works in real life — application, not theory.”
That was capture.
In processing, I rewrote it clearly, tagged it #newsletter-ready, and linked it to related notes on system design.
Then I created a Thinking Note:
“Most PKM advice stops at capture and storage. What’s missing is the middle — how raw notes become usable. This issue can act as that bridge.”
Here’s what that layering looked like step by step:
Raw capture: “LTN → show in practice, not theory.”
Processed note: “Newsletter idea: Walk through how LTN layers (capture, processing, thinking notes) shape my real projects.”
Thinking Note: “The key insight is that readers don’t need another framework. They need to see how layering carries notes forward into real work.”
When I opened my newsletter project hub, those notes were already waiting. Drafting wasn’t about invention; it was about assembling pieces I’d already built.
Deep dives that build themselves
The Mihaly Csikszentmihalyi deep dive followed the same trail. It started with a highlight in Flow:
“Flow happens when challenge meets skill.”
That was capture.
In processing, I linked it to older notes I’d written on focus, distraction, and creativity.
Then I wrote a Thinking Note:
“Flow isn’t just psychology — it echoes Stoic ideas of self-mastery. Interesting bridge: Epictetus on choosing contests vs Mihaly on balancing challenge.”
That note ended up feeding directly into one post in the thread:
“Flow is balance. Not just in modern psychology, but in philosophy too. Mihaly and Epictetus were pointing at the same truth from different angles.”
At one point I thought I didn’t have enough material for a full deep dive. Opening the project hub proved me wrong. The outline was already there, sitting in clusters of Thinking Notes.
Building products from the ground up
The Knowledge Vault Notion template started with fragments in my journal: screenshots, quick lines like “make review cycles visible,” and notes on friction points.
That was capture.
In processing, I tagged them #template-build and connected them to examples from Threads.
Then I created a Thinking Note:
“Templates fail when review cycles are buried. Design must surface review prompts at entry points.”
That idea became a guiding principle. For example, instead of hiding reviews in a separate page, I placed them directly on the dashboard where I do daily work.
By the time I moved into the project space, I wasn’t starting with a messy list. I had design principles already shaped by Thinking Notes. The final dashboard wasn’t brainstormed in one sitting, it was layered into existence.
Why layering matters
Without layers, notes either sit untouched - captured but never used, or get over-polished into dead ends.
With LTN, each step has a job:
Capture keeps the spark alive.
Processing adds clarity and connection.
Thinking Notes turn fragments into insights that last.
Projects simply draw on those insights. The heavy lifting has already been done inside LTN.
This week’s reflection
One surprise I found in my own system: a journal entry on “tagging by purpose” that I’d left untouched for months. In processing, it was just a tidy sentence. As a Thinking Note, I connected it to how people tag tasks by energy levels.
Months later, that note resurfaced and became the framing for an entire Threads post.
That’s the quiet power of layering: old fragments become fresh ideas when they’ve been given just enough shape to last.
So here’s your prompt:
Pick one note in your system. Ask: Could I move this one step forward?
From raw jotting into a clear note.
From a clear note into a short reflection.
You don’t need my template to try this. Notebook, Notion, Obsidian — the principle works anywhere. The important part is the shift, not the tool.
Creator Block
Next week’s deep dive turns to Robert Greene.
Before The 48 Laws of Power became a bestseller, Greene spent years building a mountain of notecards. One idea per card. Each filed by theme, shuffled, and layered until chapters revealed themselves.
It wasn’t speed that made his books endure. It was patience layered into notes.
On Saturday, I’ll share how Greene’s analog system worked — and why it’s a blueprint for anyone building a knowledge vault today.
Follow me on Threads @gavin.create for the full deep dive.
What I’m Building
I’ve been refining the Layered Thinking Notes template in both Obsidian and Notion. These are the same dashboards and flows I use for every project you’ve just read about.
If you’d like to try LTN in your own system, you can explore it here
That’s all for this week,
Until next time,
Gav
