Note-taking apps are a bit weird. Most productivity apps you use every day have an obvious and tangible output that you spend all your time working towards. For example, the point of using Photoshop is to make an image. You spend all your time futzing with an image and eventually you get an image to use somewhere.
But the notes in a note-taking app are not really an output you directly use. Some people and systems approach them as if they were the goal but I think this is a mistake and explains why people often have bad experiences with note-taking apps.
So if not notes then what are we actually trying to achieve with a note-taking app? In a single phrase: deep learning (for humans, not the ML kind). The output we are looking for is the mental change that occurs via the process of note-taking that deepens our understanding about the things we care about: a topic of interest, ourselves, the world around us. By spending time taking notes we become smarter; our crystallized intelligence grows.
This means that a note-taking app is a cognitive tool, not a document manager. Most apps are built as the latter, which I think is why many people struggle with them.
So if the primary goal of a note-taking app is to deepen our understanding of the things we care about, how do we go about designing for that? Well, first we need to understand how learning works, which I think can be broken down into three main components:
Externalizing: Getting ideas out of your head and into a trusted system
Internalizing: Synthesizing what you've externalized into new insights and understanding
Resurfacing: Reinforcing your understanding through spaced retrieval and repeated engagement over time
These three processes feed on each other. Externalizing produces the raw material to internalize which sparks new ideas to be externalized while resurfacing what you've externalized and synthesized deepens your understanding and sparks new insights. Without all three you can get stuck. If you don't externalize, ideas are stuck in your head. If you only externalize, you're left with a bunch of notes that serve no one. If you don't resurface and review what you've externalized, your understanding is shallow and quickly fades.
Deep learning requires all three components working together in a virtuous cycle.
Where things go wrong for most note-taking systems is too much friction with one or more of these components. Friction during externalization keeps thoughts locked in your head. This might be due to an organization system that is too complex (too many options for creating a new note) or too simple (you don't trust the organizational system to find the note again). If you can't easily find and connect old notes, you miss the synthesis that deepens understanding. If the system doesn't support resurfacing those notes over time, your knowledge fades away. Designing a note-taking app around deep learning means minimizing friction at each of these stages.
While the goal of a good note-taking app should be to minimize the friction of the note-taking process, you can never completely eliminate it because some friction is learning. Having an LLM write your notes for example would be counterproductive, you skip the necessary friction that causes learning to occur. Actual learning requires the friction of articulating vague thoughts into precise language, the friction of recognizing connections between notes, the friction of intentional recall that reinforces and strengthens your memory.
A well-designed note-taking system minimizes accidental friction that gets in the way while preserving the productive essential friction that results in deep learning. It should feel natural and freeing to quickly capture thoughts as they come, knowing the system will help you find, organize, and revisit them later. It should resurface old insights to strengthen your memory and reveal new connections. It should amplify rather than replace your thinking.
This is the kind of system I'm trying to build with Flint, which is designed around the idea that note-taking is about deep learning and tries to minimize the accidental friction you encounter by:
using higher level abstractions in the UI than files and folders
making linking effortless
using Arc-style tabs that help you organize notes with your spatial memory
using a LLM agent to help with organization
using a LLM agent to resurface old notes to cement your memory
Over the next few weeks, I'll dive deeper into how Flint's design reduces friction and contributes to each of the components that enables that deep learning cycle in practice. But the core idea is simple: a good note-taking app should get out of the way while keeping you engaged with the friction that matters.
Flint is a new note-taking/thinking-system I’m working on that fixes a lot of the frustrations I’ve had with traditional note-taking apps (or at lest it will try to fix those frustrations 😅)
I’ve long been obsessed with note-taking systems in both paper and digital forms because I love the idea of a system that helps me think better.
At the start of this summer (after freeing up a bunch of my time) I started experimenting with how to best improve my personal note taking system using LLMs. One of the outcomes of those experiments was flint-note-mcp an MCP server that gave LLMs the ability to write and manage a directory of structured notes. It was an attempt to see just how far you could push note taking away from a UI. Just chat with any LLM and have the AI write your notes.
The MCP server was an interesting experiment but ultimately it made me realize two things. First, LLMs are magic and have serious potential but also they have a tendency to take over your thinking, which is the opposite of what you want in a good note-taking system. Second, I really needed a good UI.
So, I started working on Flint, an attempt to make a good UI that uses LLMs in a way that won’t harm your thinking.
I’ll write a bunch more about all of this but the main philosophy behind Flint is this:
You own your notes. Flint is plaintext-first. No lock-in and no complex formats that make migrating to a different system a pain. Flint just makes normal markdown files on your hard drive. Eventually I might add an optional sync system but your notes will always start as just normal text files on your computer that you control.
A UI that is humane. The UI should surface appropriate abstractions that respects the way you think. This means you mange notes rather than files and folders. The UI should give you a workspace where you can make a mess and also give you tools to clean it up.
Writing is thinking and you do the thinking. LLMs are incredible bits of magic but they can easily damage your thinking by automating your writing. Flint will incorporate LLMs and AI agents in a way that allows you to be ambitious with your thinking system without replacing the writing and thinking work that only you can do.
I’ve got a bunch more thinking, writing, and building to do but if this sounds interesting to you, go subscribe to the Flint newsletter where I’ll send out links to the beta when it's ready. If you have any questions just shoot me an email at tim@flintnote.com.
I watched the OpenAI livestream introducing GPT-5 today and had some thoughts.
First, the presentations were all oddly stilted and awkward. Most of the presenters seemed to be mimicking Sam Altman's affect. It was weird, like I'm not expecting them to be as polished as an Apple keynote (even then Apple has a spectrum of polish) but like maybe they could have done a few more run-throughs?
Second, they had blindingly obvious errors in some of their graphs. They had a bar chart where 52 was taller than 69, which was the same height as 30. Clear case of automation bias since I'm sure they had GPT-5 check for errors and it didn't catch it so the humans didn't either.
Third, one of the demos they had was of GPT-5 explaining the Bernoulli principle in relation to how flight works. It made a web visualization showing how lift is created based on the principle and how air travels over a wing. The wild thing is that the Wikipedia page on the Bernoulli principle calls out how this is a common misconception. Now, maybe the details of the demo were actually correct but it was hard to tell from just watching (Hacker News had a good time nerdsnipping themselves over it). Strange that they went with this example because it's so fraught with misconceptions and easy to get (subtly) wrong.
Also, not a huge point, but they kept saying how GPT-5 was like having a PhD in your pocket. As a PhD haver who has worked with plenty of other PhD havers, this is just so funny. Like I get what they are trying to communicate (it's so smart!) but it's not nearly as impressive as it sounds (in the same way that Bruce Banner having 7 PhDs is supposed to read as smart but is completely absurd). People really need to understand that a PhD does not make you smart.
I've been experimenting with trying to build a plain-text GTD system with Flint. I started by just creating a todo note type with a couple of simple metadata fields (e.g. status, due date, etc.) with agent instructions to keep things concise and action-oriented.
Creating and updating todos then happens conversationally:
Me: make a todo to schedule a dentist appointment today
Agent: Done.
Later in the day:
Me: mark dentist appointment done
Agent: Updated.
My favorite part of this approach is you can then ask the agent "what should I be working on today" and it's generally smart enough to look through all your todos but also other kinds of notes (daily logs, project notes, etc.) and give you a pretty intelligent response.
This is fine but gets awkward to update multiple items at a time. What I wanted was a way of seeing and updating multiple todos at a time while still keeping the benefits of text and agent smarts. So I just asked Flint to make me a special note that it would keep in sync:
Me: create a todo note that is special called "today", it should:
list all the other todo items that should be worked on today
format items like - [ ] todo item.
update agent instructions to update this note when updating other notes
when the note has items checked off, synchronize with corresponding note status
have a section called "Quick Add New Tasks" to easily add new items
each todo should be in one of three states: now (I want to focus on working on it today), upcoming (ready to be worked on soon), someday (a backlog of stuff to plan out eventually)
the today note should group by status but not show all the someday tasks (just show a count)
items in the now section should be written like - [ ] + todo item and items in the upcoming sections are written like - [ ] todo item.
when syncing the today note look for changes to the + to move items from the now state to the upcoming or vice versa
Flint then made a "todo" note that looks like this:
# Today - [Current Date]## NOW (Focus on today) 🎯- [ ] + Finish quarterly report draft
- [ ] + Review team feedback on project proposal
- [ ] + Schedule dentist appointment
- [ ] + Follow up on client contract (OVERDUE)
## UPCOMING (Ready to work on soon) 📋- [ ] Plan next week's team meeting (Due: Friday)
- [ ] Update budget spreadsheet (Due: End of month)
- [ ] Research new project management tools
## Quick Add New Tasks*Add new todo items below - use + for NOW, - for SOMEDAY, no symbol for UPCOMING*- [ ]
- [ ]
- [ ]
Now I can easily check off (e.g. change [ ] to [x]) multiple items and then ask Flint to sync the note and it will update each todo note as completed and refresh the today note.
A day's interaction could look something like this:
Morning (9:00 AM):
User opens Today note, sees:
- [ ] + Write project proposal
- [ ] + Call insurance company
- [ ] Review budget numbers (Due: Thursday)
User adds + symbol to "Review budget numbers":
- [ ] + Review budget numbers (Due: Thursday)
System automatically:
- Updates individual todo note workflow_state to "now"
- Moves task to NOW section in Today note
Midday (1:00 PM):
User checks off completed task in Today note:
- [x] + Write project proposal ✅
System automatically:
- Updates individual todo note status to "completed"
- Adds completion timestamp
- Moves to "Recently Completed" section
Evening (6:00 PM):
User adds new task to Quick Add section:
- [ ] + Book flight for conference
System automatically:
- Creates new individual todo note: "Book flight for conference"
- Sets workflow_state to "now" (because of + symbol)
- Adds to NOW section in Today note
- Clears the Quick Add entry
I think this is pretty cool, you can build an approximation of a full-fledged GTD app like Things or OmniFocus in plain text just by writing down a few simple instructions.
Another neat thing is I built this workflow conversationally. My example above defined the today note in one instruction but I actually went back and forth with the agent a bunch to narrow down how the today note should best be structured.
This bidirectional sync between plain text and AI agents feels like a fundamental building block. You get the benefits of structured data and automation while keeping the flexibility and ownership of plain text. I suspect this pattern will be useful beyond task management.
Update, October 2025: This post introduced an initial experiment with using MCP for note-taking that has morphed into something bigger. Check out this post for more details.
I'm obsessed with note-taking systems. I've been obsessed with them for most of my computer-using life. Evernote, Notion, Roam, Obsidian—each promised to be my "external brain". I spent hours building out workflows to help me think and act on the things that mattered to me. But inevitably I would hit the same wall when my system became unmanageable and I had to start over from scratch.
Here's the problem: your thinking changes. Your projects shift. Your interests expand. But most note-taking systems lock you into structures that become prisons over time. Maybe you organize by project phases—"Research", "Planning", "Execution", "Review". Then you start working on iterative projects that don't follow linear phases, and your structure crumbles.
You either stick with categories that no longer fit, or you abandon the system entirely and start over.
Now AI promises a solution: just dump everything into a smart assistant and let it handle the thinking for you. Sounds perfect, right?
Maybe, but I think that approach is dangerous.
When we fully outsource our thinking to AI, our thinking atrophies. Think about the Google Maps effect: before GPS, we mentally mapped neighborhoods, remembered landmarks, and built spatial reasoning. After GPS, we can't navigate familiar areas without turn-by-turn directions. The same thing happens with AI-assisted thinking.
The messy work of organizing ideas, making connections, and structuring knowledge isn't busy work—it's how we actually think and learn. Automate that away, and you're automating away your own intelligence.
Plus, you're handing over your most valuable asset—your accumulated knowledge and thinking—to systems you don't control.
So here's what I want: an AI thinking system that I control and that augments my thinking instead of replacing it.
Instead of throwing everything into an AI void, imagine an agent that works with you based on your explicit preferences for how you want to think and organize. You tell the system what kinds of notes you work with—daily journals, project logs, book summaries, meeting notes, research captures—and what workflows matter to you: weekly reviews, concept mapping, progressive summarization, or building arguments over time.
For example, you specify that you keep "insight notes" and "reference notes" separate, and prefer connecting ideas through explicit linking rather than tagging. The AI then notices when you write about "flow state" in an insight note, remembers you mentioned "deep work" in a book reference from 6 months ago and "maker's schedule" in a meeting capture, then suggests creating a synthesis document that fits your preferred workflow—maybe a new insight note that builds on these connections, or links to add to your existing concept map.
Or when your project logs increasingly reference the same underlying problems across different domains, the AI suggests a reorganization that aligns with how you actually think—perhaps shifting from department-based folders to problem-solution frameworks, but only because you've indicated you prefer outcome-oriented organization over categorical filing.
The AI handles the friction—the tedious reorganization, automatically tagging notes with concepts and people mentioned, the structural updates—while you focus on the actual thinking. The goal isn't to eliminate the work of thinking. It's to eliminate the work that gets in the way of thinking.
This vision sounds great in theory, but how do you actually build it? The traditional approach would be to create another proprietary platform, which is exactly the kind of lock-in I want to avoid. Instead, we need a way for AI models to work with your note-taking system while keeping your notes completely under your control.
This is where I think Model Context Protocol (MCP) unlocks something special. Unlike proprietary systems that lock you into a platform, MCP unlocks the potential for any AI model to work with your data while you stay in control.
Consider the difference: In traditional systems, your notes are locked in Notion's proprietary format. Want to switch to Obsidian? Technically there is an export but the export breaks formatting and loses connections. Company gets acquired? Your thinking system disappears.
With an MCP-enabled system, your notes can just be files in a folder. The AI agent reads and writes through the MCP protocol, but you can switch AI models, sync services, or editing tools without losing anything. Your 10-year+ knowledge base outlasts any single company or platform.
But unlike traditional file-based systems like Obsidian where you're on your own for organization, the AI agent becomes your active partner in managing, connecting, and evolving this information.
This separation of concerns (intelligence versus data storage) enables something that wasn't possible before: true agent-first design where the AI can be deeply integrated with your thinking process and you control your data.
This isn't some distant future vision. It's what I'm building right now with Flint Note.
Flint is an MCP server that organizes your notes as a vault of ordinary markdown files with semantic note types. Each note type defines its purpose, custom agent instructions, and metadata schema. Let me show you how this works in practice by walking through setting up a vault with three common note types.
You: lets create three note types: daily, todo, and reading
Agent: I'll create all three note types for you: daily, todo, and reading. Let me set each one up with thoughtful agent instructions and useful metadata schemas.
Agent Behavior: Structures notes with summaries and key ideas, identifies connections to other materials, and encourages critical thinking
Your vault is now ready for comprehensive knowledge management! You can start creating notes of any of these types. Just say something like:
"Create today's daily note"
"Add a todo list for this week's tasks"
"I want to create a reading note for [book/article name]"
What would you like to create first?
The resulting daily/_description.md looks like this:
# Daily## Purpose
Daily journal entries for reflection, planning, and personal
growth tracking
## Agent Instructions- Structure daily notes with clear sections: Morning
intentions, daily events, evening reflection
- Extract and highlight key insights, lessons learned,
and personal growth moments
- Identify patterns in mood, energy, productivity,
and relationships
- Suggest connections to previous daily entries when
similar themes emerge
- Encourage reflection questions: What went well? What
could be improved? What am I grateful for?
- Track recurring themes and suggest deeper exploration
through follow-up questions
- Notice and celebrate small wins and progress toward
personal goals
- When appropriate, suggest creating separate notes for
significant insights or ideas that emerge
## Metadata Schema
Expected frontmatter or metadata fields for this note type:
-`mood`: Overall mood for the day (optional, select,
options: [`energized`, `content`, `neutral`, `tired`,
`stressed`, `excited`, `reflective`, `grateful`])
-`energy_level`: Energy level (1-10 scale) (optional,
number, min: 1, max: 10)
-`gratitude`: Things you're grateful for today (optional, array)
-`key_events`: Significant events or moments from the
day (optional, array)
-`insights`: Key insights or lessons learned (optional, array)
-`tomorrow_focus`: Main focus or intention for
tomorrow (optional)
Since the description is just a plain text markdown file, you can have the agent update it or edit it yourself with a text editor.
Adding Notes Through Natural Conversation
Now let's see the system in action:
You: Add today's daily note
Agent: [Creates daily/2025-06-27.md with structured content]
Perfect! I've created your daily note for today, June 27, 2025. Following the agent instructions for daily notes, I've structured it with clear sections to guide your reflection:
Morning Intentions (Space to set your focus for the day)
Daily Events (Capture key moments, interactions, and accomplishments)
Evening Reflection (Process how the day went with guided questions)
Gratitude Section (Practice appreciation)
Key Insights & Lessons (Extract learning and growth moments)
Tomorrow's Focus (Set intention for the next day)
The note is ready for you to fill in! As you use it, I'll help you:
Identify patterns in your mood, energy, and productivity
Connect themes to previous daily entries
Celebrate your small wins and progress
Extract insights that might be worth exploring in separate notes
You can also add metadata like your mood, energy level (1-10), and specific gratitude items if you'd like more structured tracking. How would you like to start filling it in?
You: My energy is about a 7, pretty good energy
Agent: Great! I've updated your daily note to capture that energy level of 7. That's solid energy for the day!
With that good energy level, it sounds like you're having a productive day. What's been contributing to that energy? Any particular events, accomplishments, or moments that have stood out so far today?
I can help you capture those in the daily events section, or if you're reflecting on the day, we could work on the evening reflection part. What would you like to add to your daily note?
Adding a reading note:
You: Add a reading note for "The Unaccountability Machine" by Dan Davies. I've finished it, here's a great quote:
"An organisation does things, and it systematically does some things rather than others. But that's as far as it goes. Systems don't make mistakes – if they do something, that's their purpose."
Agent: Excellent! I've added that powerful quote and updated your reading note to show you've completed the book. That's a really striking insight – the idea that "systems don't make mistakes, if they do something, that's their purpose" cuts right to the heart of how we think about organizational accountability.
Since you've finished the book, I'd love to help you capture more of your insights:
What was the main thesis that resonated most with you?
How does this quote connect to the broader argument about unaccountability?
Are there specific examples from the book that illustrate this "systems don't make mistakes" principle?
Does this change how you think about organizations you've worked with or observed?
This seems like the kind of concept that could warrant its own separate note if it becomes a recurring theme in your thinking about systems and organizations. What other key takeaways stood out to you from the book?
[Creates reading/the-unaccountability-machine.md with the quote and reading status]
Evolving Your System
The real power emerges when you want to adapt how the system works:
You: Update my daily notes to also ask about tomorrow's top priority
Agent: I'll modify your daily note instructions to include planning tomorrow's main focus.
[Updates daily/_description.md to add tomorrow planning prompt]
Updated! Now when you create daily notes, I'll also ask: "What's your top priority for tomorrow?" This will help bridge your reflection with forward planning.
You: Actually, make it three priorities, not just one
Agent: Good adjustment! Three priorities gives you more flexibility while still maintaining focus.
[Updates the instruction again]
Done! I'll now ask for your top three priorities for tomorrow in each daily note.
The Result: Intelligent, Adaptive Organization
What you end up with is a system that understands the different contexts of your thinking:
Daily notes become reflective conversations that build self-awareness over time
Todos match tasks to your energy and connect to bigger projects
Reading notes capture insights with precision and link to your active work
But unlike rigid templates, every aspect can evolve through natural conversation. The AI learns your preferences and adapts its behavior, while your data remains simple markdown files you can edit anywhere.
The system grows with you, becoming more intelligent about your specific needs while keeping your information completely portable and under your control.
Why This Matters
We're at an inflection point where AI can finally deliver on the vision of an external brain that truly enhances thinking. But only if we're willing to rethink our assumptions about how knowledge systems should work.
Most AI-enhanced note apps are still designed for the old world where humans do the organizing and AI occasionally helps out. Flint flips that: the AI is your thinking partner from day one, and the system is designed to make that partnership as natural and powerful and flexible as possible.
Since all your notes are just markdown files, there's no lock-in. You can work on your notes with Flint, or fire up vim or Obsidian or iA Writer or any other local markdown editor you want. You can sync or backup with whatever file syncing service you already use (git, Dropbox, iCloud, Obsidian Sync, etc.).
But unlike other markdown-based systems, Flint is architected from the ground up to be agent-first. Every design decision (from the vault structure to the metadata schemas to the conversation patterns) optimizes for AI collaboration rather than human maintenance.
Getting Started
If this sounds interesting, you can try Flint by adding it to your MCP client of choice. You'll need Node.js installed first:
I've also created system prompts to help guide your model's interactions: system_core.md for intelligent models like Claude 4 or ChatGPT 4, and simple_models_detailed.md for simpler or local models.
The project is still early, but if you try it out I'd love to hear what you think. The system is designed to evolve based on how people actually want to interact with their knowledge.
Check out the GitHub project to dive deeper, or just give it a try. The future of knowledge work is agent-first, and Flint is my attempt to build part of that future today.
Jotting down an aha! moment I had about how MCP can augment the utility of LLMs in some of the things I do every day.
The background is I've been trying to be more intentional about committing things to memory using Anki and spaced repetition. I was inspired years ago by Michael Nielsen's article about using SRS to read and remember ideas from papers so that's my main goal: commit interesting ideas from papers to memory.
When I first read that article I tried to build an Anki routine but fell off—the activation energy required to add cards was always too high (also writing good prompts is hard).
LLMs are really good at summarizing and restructuring text so I wondered if they could help with writing Anki cards. I'm not sure if this is the right approach long-term since writing cards by hand would almost certainly aid in the learning process. That said, it turns out I couldn't sustain the manual effort so I think it's worth experimenting to see if a different approach could help.
So my approach is to use an LLM to help write the cards. MCP then lets me easily connect the LLM directly to Anki and even further reduce the activation energy required for authoring cards.
I'm using Raycast, but the basic idea works in any MCP-capable LLM client (e.g. Claude desktop). The MCP server I'm using is anki-mcp-server, which requires Anki and the AnkiConnect plugin. Wiring up the Anki MCP server to Raycast is super straightforward and took me all of five minutes.
For articles, there are a few kinds of prompts that seem to work. If the article is well-known and in the model's training set, you can simply say:
suggest some anki cards for the article "As We May Think" by Vannevar Bush
Claude 4 responds with something like:
Basic Information Cards
Card 1:
• Front: Who wrote "As We May Think" and when was it published?
• Back: Vannevar Bush, published in The Atlantic Monthly in July 1945
Core Concepts
Card 2:
• Front: What is the "Memex" as described by Vannevar Bush?
• Back: A hypothetical electromechanical device that would store books, records, and communications, allowing users to retrieve and link information through associative trails
...
For newer or less well-known articles, you can paste the entire article or a URL (if the model supports web browsing). Not every suggested card will be useful, sometimes the model suggests trivia I don't care about, but it's easy to go back and forth with the model to pick the best ones. You can also add some pre-prompt instructions to guide the model toward the kinds of cards that are most helpful, but honestly, it's quick enough to just pick out the good ones.
Once I have the cards I like, it’s a simple instruction to add them to Anki:
now add those cards to @anki
(Raycast uses the @ notation to add an MCP server to a chat, but you can also provide it as a chat preset.)
Raycast also provides a nice feature to wrap commonly used prompts in AI commands. For example, I’ve added an “ankify” command with a prompt like:
from the article in {browser-tab}, suggest some anki cards to help me remember the salient points. when referencing the article use a short version of its title and link to it
This does what it sounds like: it provides the currently focused browser tab as context to the model. I can then check the suggested cards and follow up by telling it to add them to my Anki deck.
I think it's pretty neat that thanks to MCP we can now wire up these powerful capabilities to our LLMs in a matter of minutes.
Big changes happening in my life. After almost a decade, today was my last day working at Shape Security / F5.
It was a really good run. I had the chance to work with incredible folks building wild things on the web and I think we make it a little safer and more convenient for everyone.
Now it's time for something completely different. Not entirely sure what that is yet but I'll figure out something fun soon.
Tim Disney
