How to use Quickscriber to organize your thoughts/ideas

It has been quite a while since I last posted here. I've been busy building stuff for the Mac - and one of those things, Quickscriber, finally got an MCP server, which means it's time to write about it 😄

So anyway, a quick bit of background for anyone who hasn't used Notational Velocity. NV was this beautifully minimal Mac app from way back - no folders, no save button, just a hotkey, a search box, and a blank space to type into. You hit the shortcut, the window pops up, you type, you hit the shortcut again, it's gone. The genius of it wasn't really the features (there weren't many), it was that it got out of your way. Capturing a thought took exactly as long as typing the thought.

Quickscriber is my attempt to bring that same idea forward to a modern Mac, with Markdown, Mermaid diagrams, KaTeX, the works. But the part I actually want to talk about today is the thing NV never had and honestly couldn't have had in 2010: an MCP server, so an AI agent - Claude Code, in this case - can read and write your notes directly.
​
That sounds like a small feature. It is not a small feature. Let me explain why.

Engineering managers and idea dumping

Being an engineering manager (or really, doing any job with lots of small unstructured inputs) means your day looks something like this: someone mentions a flaky test in passing, you have a half-formed thought about reorg during your commute, a Slack thread surfaces a risk nobody's tracking, you remember mid-meeting that you still haven't followed up with Jose about the tech lead thing.

None of that is a "document." None of it deserves a ticket yet. But all of it needs to land somewhere, immediately, or it's gone.

That's the capture problem, and Quickscriber solves it the same way NV always did - friction approaching zero. But capture was never really the hard part. The hard part is what happens to all those notes after you've dumped them. Normally: nothing. They just sit there until you manually go digging, usually right when you need them and can't remember what you titled the thing.

MCP Servers and how to set it up

This is where Claude Code comes in. It can do the digging for you.

AI agents are getting better and better, and the biggest innovation the past year is their ability to use tools. The key thing is how to tell your agent that these tools exist. That is where the MCP server comes in - it lets your AI agent know that you applications have tools available for it to use. So let's set one up. For this example I'm going to show you how it is done with Claude, but in theory you can use it with any agent (even local, with LM Studio and an open-weight LLM like Qwen for example. I'll write something up for that later).

OK, let's get into it. Open Quickscriber, go to Settings → Integrations, and flip on Enable local MCP server. You'll see something like this:

• Port: 8765 by default
• Token: a UUID Quickscriber generates for you
• Full URL: http://127.0.0.1:8765/sse?token=YOUR_TOKEN

Copy that URL, then register it with Claude Code from your terminal:
claude mcp add --transport sse quickscriber "http://127.0.0.1:8765/sse?token=YOUR_TOKEN"That's it. Restart your Claude Code session and you'll have access to five tools:

• list_notes - list/filter your notes
• get_note - pull the full content of one
• create_note - make a new one
• update_note - edit an existing one
• delete_note - remove one

A couple of things worth flagging before you go wild with this, because they actually matter:

• It's local only. Traffic stays on 127.0.0.1 - nothing's leaving your machine.
• It is NOT encrypted. It's bearer-token authenticated, which stops randos on your network from just guessing the URL, but the traffic itself is plaintext. Don't get clever and port-forward this thing to "access your notes from anywhere", unless you truly know what you are doing. That's a great way to leak your notes to anywhere. It is better to just use the iCloud sync feature for that.

​Making sense of the data

OK but what do I actually DO with this? Right, the fun part. Here's the workflow I've landed on, and the thing to understand is it has two completely separate phases that you should NOT try to do at the same time:

Phase 1: Capture everything, don't think

Hotkey, type, hotkey, gone. Don't tag it, don't decide where it belongs, don't even finish the sentence if you don't want to. A day's worth of this looks like:

• "deploy pipeline flakes ~1x/week per Sarah, nobody's tracking it"
• "backfill plan if Jake's leave overlaps the migration?"
• "push back on analytics rewrite in Q3 planning, not scoped"
• "ask Priya - tech lead role on payments?"

Phase 2: Let Claude Code impose structure on the pile, after the fact.

This is the part NV never had an answer for, because NV had no idea what was in your notes. It could find them, but it couldn't think about them. Claude Code can. Turning yesterday's noise into today's TODO list. Some examples - instead of starting your morning trying to remember what was urgent, just ask:

"Pull my Quickscriber notes from the last 2 days and draft today's TODO, prioritized by anything time-sensitive or blocking someone else."

• Internally, Claude Code calls list_notes, reads through it with get_note, and hands you back something sorted - which it can write right back into Quickscriber as a new note via create_note. Now your TODO list lives in the exact same hotkey-accessible window as everything else, and you can update_note it as you check things off through the day.

"Search my notes from the last two weeks tagged #idea or #eng-priority, cluster them into themes, and draft a one-paragraph proposal for each I could bring to planning."

• Same as above, Claude Code will look through all your notes and do a weekly triage of the stuff that's been quietly piling up

Maybe you just want to tidy everything up:

"Find notes older than 30 days that look resolved based on later notes, and tell me which ones you'd delete - don't delete them yet."

More on that "don't delete them yet" bit in a second.

Now here's where it gets actually interesting: combine it with other MCP servers!

This is the part that took the idea from "nice feature" to "oh, this changes how I work" for me. Claude Code doesn't just talk to Quickscriber - it can talk to Quickscriber AND your JIRA board AND your Google Calendar in the same breath, which means your scribbled notes can become real, scheduled, tracked work without you ever opening JIRA or Calendar yourself.

With Jira MCP configured: notes become sprint tickets. Say you've got a pile of half-formed engineering complaints sitting in Quickscriber from the week. Instead of manually transcribing each one into a ticket (the part of ticket-filing everybody hates), you can say:

"Look at my Quickscriber notes tagged #eng-debt from this week. For each one that's concrete enough to be actionable, create a Jira ticket in the MOB project with a title, description, and the tech-debt label. Then update the Quickscriber note with the ticket link."

Claude Code reads the note with get_note, creates the ticket through the Jira MCP server, then calls update_note to write the ticket URL back into the original note. Now your scratch note and your tracked work are linked, and you never typed the same sentence twice.

You can go the other direction too:

"Pull my open JIRA tickets assigned to me with status 'In Progress', and create a Quickscriber note for each one I haven't touched in 5+ days, so I remember to follow up."

That's Jira's structured-but-buried data becoming a fast, searchable scratch note again. Round trip complete.

Quickscriber + Calendar - your personal assistant

With Google Calendar MCP configured, notes become actual time on your calendar. This is the one I didn't expect to like as much as I do. A lot of EM notes are really just "I need to have a conversation with someone," and those conversations have a way of never happening unless they're on a calendar.

"Find Quickscriber notes mentioning a 1:1 topic with Jose, summarize them into talking points, and create a calendar event for our next 1:1 with those points in the description."

Or, for the planning-cycle stuff:

"I have a note about pushing back on the analytics rewrite in Q3 planning. Create a 30-minute prep block on my calendar sometime before Thursday, and put a summary of my argument in the event description."

Claude Code does the thinking (turning a half-sentence scribble into actual talking points), the Calendar MCP server does the scheduling, and Quickscriber stays the single place you dumped the original thought. None of the three tools needed to know about the other two ahead of time - that's the whole point of MCP, really.

Other combos worth trying

A few more I've poked at, in roughly ascending order of "how much do I trust the agent to just go do this":

• GitHub MCP: "Notes tagged #bug from this week's meetings - check if there's already an open issue matching, and if not, file one."
• Slack MCP: "Summarize today's Quickscriber notes into a short end-of-day update and draft it as a message to #eng-leads, but don't send it yet."
• Email MCP: "Turn this note about the vendor contract concern into a draft email to legal, and leave it in drafts."

Notice the pattern in basically all of these: Claude Code drafts, you approve. That's not me being timid for no reason. Here's the thing about create_note, update_note, and especially delete_note: you're giving an agent write access to a data store.

Same logic applies once you've got Jira, Calendar, GitHub, Slack, and email all wired up - an agent that can create a ticket can also create fifty of them by misreading your intent, and one that can draft a calendar invite can, with a slightly different prompt, just send it.

So a couple of habits I'd actually recommend, not just as a disclaimer to cover myself:

• Tell Claude Code explicitly, once, in your instructions: "Always show me what you'd delete/create/send before doing it." It'll remember for the session, and you can make it a standing instruction. Always have a verification loop.
• Treat delete_note as a propose-then-confirm action, always. "Tell me what you'd delete" is a different and much safer request than "delete the old ones."
• If your Claude Code setup has broad auto-approval turned on, carve out an exception for Quickscriber's write tools and anything that sends/publishes externally (Slack, email, calendar invites to other people). Reading is low-stakes. Writing to a system with no backup, or writing to a system other people will see, is not.

None of this is a reason not to do it - it's a reason to keep a human in the loop on the irreversible steps, same as you would for literally any tool that touches production.

The thing I actually like about this setup is that it doesn't ask Quickscriber to be anything other than what NV always was - a frictionless place to dump a thought before it disappears. It just adds a second half to the equation that never used to exist: something that can come along after the dumping is done, read the whole pile, and turn it into a TODO list, a sprint ticket, a calendar invite, whatever the thought actually needed to become. Capture stays dumb and fast, on purpose. Structure happens later, on demand, and you don't have to be the one doing it.

That's it for this one - go set up the MCP server, dump some thoughts in there, and see what Claude Code does with them.