Little-t tools for thought

Something a little different today:

While you probably know me and this newsletter as being primarily concerned with government and policy and technology and the intersections of all those things, what you might not see, but which is underneath and in corners here and there, that I care a great deal about is — tools that can be used to increase agency.

In fact, if I myself had to say one thing that really made the gov + tech intersection compelling to me in the first place, it was that I found sources of leverage (in the form of web software) on problems that felt very stuck, very fixed otherwise.

And one thing that seems to me very true about this current set of large language model capabilities is that a lot of the pieces of software that confer agency have become much easier to build, and quickly too cheap to bother metering.

What cheap cloud deployment and APIs meant a decade ago I think vibe coding and agentic AI coding environments bring a new step function to today.

Much hay has been made about the concept of tools for thought - the bicycle for the mind, Licklider, Alan Kay, all that great stuff you find in that rather erudite and thoroughly Haskell-competent corner of Twitter.

But the thing that I've been very excited about lately (in the 5-10 minutes a day I have to be independently excited about anything neither work nor home-work) is the possibility that quite soon I might have at my disposal much better forms of the “lowercase t tools for thought” that I've hobbled together across many different systems here and there.

And I'd like to share some of that.

My brain works in a way that my best ideas come to me when walking or doing something else. How dreadfully unique, I know!

A core lowercase tool for thought for me is the ability to capture those ideas then and there — without losing my same thought, with minimal friction, in a place where I can get back to it, and in fact in a place that I will get back to it.

How do I do this today? Well, like every good plumber/programmer, I do a very duct tape job of it. Here's what I do:

I use Siri to text a phone number in my iPhone, which is saved as Too Do, because that way it actually works semi-consistently when I say “text to do.”

That phone number is a Twilio one, and on the Twilio side, it has a little snippet of JavaScript running in its little Twilio serverless environment. That takes the body of my text message and creates a new item in my Asana (which I use to capture lots of things and manage lots of things.)

Frictions here that I would like to go away include:

- Approximately once every hundred times, I end up texting a todo to my friend Cyd. Because somehow my Siri think that “to do” and “Cyd” sound similar.

(Aside: I'm transcribing this blog post on Wispr Flow which works an order of magnitude better than Siri, an overhang that I am shocked has lasted more than six months.)

This is, when you think of it, kind of a crazy thing to have to set up. (Yes, the Asana native app has a Siri voice command, but it is much more friction-laden! And speech friction is deeply annoying friction!)

And clearly most people are not going to be able to set it up. I'm literally paying a couple bucks a month for a Twilio phone number. And I had to have enough background to write, run, and debug a JavaScript snippet that talked to the Asana API.

I have: a full-time job; a 20-month-old; and a high medical need dog. That is to say, I have 2.3 full-time jobs.

I have found that the greatest way to reliably and consistently do things — and consistency is the real key here! because this is how compounding things happen! — has been to have a hyper-detailed daily plan: literally down to the detail of doing a particular calf stretch on each leg in 30 seconds at approximately 7:30 in the morning, just before I walk out with the stroller and up a steep San Francisco hill.

I use Obsidian for this, and it works quite well. In fact, with Obsidian Sync, I have it available on my laptop, as well as on my iPhone, and even on my Android tablet (the Daylight DC-1 e-ink device — I’m a fan!)

A nice aspect of this is that it is fundamentally (at the data structure level) just… a big old nested outline where each bullet is checkbox item.

That's a very simple data structure. And, what's more, it has one very beautiful HCI/attentional property, which is that I can collapse many parts of my 100+ things and only have a certain portion of the day/tasks visible to me: the portion with what's next and what I need to have in my working memory. And yet all of it is there in one place and easily viewable.

And yet, here too there is friction.

I use Obsidian Sync. But candidly (and I'm sure I'm not alone, but it's certainly frustrating) the sync does not work perfectly across devices. Sometimes they will get out of sync, even though all are online. Either items will be repeated, or even stuff will disappear.

While I appreciate the local first software concept, the fact that I'm using these particular and particularly different types of devices very much seems to break it.

I've looked and looked, and I am fairly certain that I do not have a way to have a local first model in an iPhone app, an Android tablet, and a MacBook app in any reasonably cost-effective use of my minute small-time.

A “template every day of an outline comprised of text boxes that are clickable” is a fairly simple data structure. And yet, the way that data permissions work on iPhone apps and Android and a laptop means doesn't really work quite well to do something local first; at least not with something quite ornate as far as I can tell.

So now my brain goes to: "Wow am I really spinning up a server and creating clients? Oh gosh. This is bad, Dave."

And you know what? Let me just go for the true nitpick here: I love my Daylight DC-1 Android e-ink device. It is a true delight, and Obsidian works quite well on it. I also quite like my iPhone.

But… the fact that Obsidian is not a true native app has very subtle effects on micro-interactions. When I give the iOS app Bear a try, the tactile sense is so much better. Yet last I looked at using a template in Bear…they literally want me to set up Shortcut workflows in iOS?! And it definitely does not seem to have good cross-platform sync.

What I don't want to lose here is: I really just want a big list of checkbox items! I want to use it on the different devices that serve me in different contexts. Yet somehow that itself is difficult.

Again, a lowercase-t tool here: the GTD, or Getting Things Done, system is something I hold near and dear to my heart.

It's not perfect, nor is it dogma, but it is an extremely effective way to offload my brain and to calmly process things and do things and get into a flow state where my working memory really is focused only on one thing, rather than the meta layer of "should I be doing something else?"

I use Asana for this, and it works pretty well (I’d say 90%). That’s especially because I have my voice capture into it via Tool 1.

If you want to know my nitpick here, it's that the concept of a project in Asana and the concept of a project in GTD are pretty different. So you end up having to use some hacky transposing logic and make some imperfect choices.

In case it's helpful to you, the way I approach this is that I use Asana projects as GTD lists. A project is just a regular old item that has sub-items in Asana. If you really commit to the bit, you can tag the next sub-item up as the next action, and that tag of next actions can represent the top sub-item of each thing that is a project.1

This is also where I think it gets interesting, because some of what I'm describing is clearly something that a passively observing agent could just take care of

In fact, I've been testing here and there the idea of an agent that just does its very best to apply the first parts of the GTD mindset when a new thing comes in:

- Is this actionable?

- Is there a visible next step?

- What might this look like decomposed into different steps under a project?

But here is the other thing: I really have no connection at all whatsoever between the Asana (where all of the things live) and the daily planner (where my working memory lives.)

Any connection there is me holding two electrical cables, one in each hand, and letting the charge flow through me. I am the glue. And as you can imagine, this is a strained position, and often leads to imperfect doing and thinking. (And madness.)

In the interest of being comprehensive about my folk system, I should mention that another little-t tool is the use of single words at the beginning of many of my capital T things.

For example, "idea:", "build:", "listen to:", "read:".

[Edit 7/23: I near forgot this one in my first version! So I am adding it now.]

I find writing notes by hand to be just plain great.

Traditionally I’d used a Leuchtturm notebook with quite thick ink, but these days I use my Daylight DC-1, an Android tablet.

What I want is for the Daylight digital notebooks I keep to be seamlessly picked up in the background by a careful, responsible agent and put into one of my other spaces (likely Obsidian? but also things I write with a (!) in my notes are todos of some variety, or at least intended to catalyze action, and so those ought to go to Asana — ack!)

• I want to be able to walk and use a voice interface to process my GTD stuff

• I want a really excellent layer to live between my daily plan (currently Obsidian) and my longer-term store of all the things (currently Asana). I don't even know what that layer is, but clearly you can think of some heuristics for smartly converting from the long-term to the acute here and now.

Kidding. (Mostly.)

What excites me about the code generation capability curve I see today is I do think that I know this folk tool system of mine in my heart and bones.

And I also do not think that any company is likely to build one piece of software that will do everything to my very finicky, specific spec.

But I do think that it is possible that — given the right rudiments and the right plumbing tools — I can make it real for myself; much as I have cobbled together pieces with my oh-so-2010 tools. (A Twilio bot?? In this economy?!)

For example, I already use Claude and the local filesystem MCP to interact with my Obsidian daily note/planner. This works quite well!

Further, at an abstract level I think if I had the hour to actually do it, I could probably cobble together something using ElevenLabs for voice that could let me talk to an LLM layer with access to my Asana. I could use this, for example, to talk through things in my inbox that need processing and make those decisions on a stroll, rather than sat down behind a desk. (Walk ‘n’ talk: not just for aging West Wing fans!)

But it is assuredly the case that we don't make this sort of thing easy, even though the capabilities are very quickly becoming pervasive and too cheap to meter.

(Two notes: first, I loved the recent Ink and Switch essay Malleable Software. And I truly love the concept behind CRDTs and automerge. But God help me if I ever end up in the situation where learning CRDTs is the lowest-friction path of building a tool where I am the sole user!)

It's also decidedly true that much of the time, coupling some core foundational capability (say, a wicked good LLM) with an application layer (say, persistent memory) makes a lot of sense to build a moat.

And I will say it's one of the things that has made me philosophically very satisfied with Anthropic nudging the market equilibrium with its Model Context Protocol, which keeps these things separate.

(Making core capability and individual context separate layers that people can pick and choose from is a big deal. That’s for two reasons: 1. choice is deeply powerful at the individual level; and 2. choice carves mountains at the societal level.)

And to be abundantly clear, I wouldn't be writing this if I didn't think that now is the time for optimism on all this!

In the course of an hour with Claude Code the other day, I built a functional MVP of something I've been sitting on for four years. Something I have tried to build maybe two or three times, and then abandoned in exhausted defeat because of EXIF image file insanity.

And here’s the thing about this: the ability to make a system that actually works for me has a first-order effect (namely, making me more effective.)

But as a second-order effect (and I know agency is a virtually meme at this point, but bear with me!) it has a second-order effect of increasing — on the margin — my inclination to push make things happen in the world more generally; to default assume conditions are mutable, rather than forever fixed. (Also: agency compounds.)

I am at this point most decidedly an aging punk dad, and the primary blessing of that background is a deeply ingrained spirit of DIY; something I fear at times is not quite the predominant spirit in the Bay Area today that it once was. But now we've reached a topic for another day; and we’ve most definitely reached bedtime.