I find Alan Watts engaging. He was a gifted explainer who could make heady, paradoxical ideas flicker into solidity and coherence. There are a few moments in the show where his ideas do come together and you get a sense of what he was about, particularly about teaching and spiritual practice.

It ended up giving Al and I something to think about afterward. She’s a member of a local Zen center. I’ve never really felt very compelled to take up a formal practice. Certainly nothing like Soto Zen. I have some contradictory feelings about it that the show resurfaced, because Watts saw some spiritual practice and relationships with teachers as a sort of revolving door one could never get out of if they don’t push us toward our “oh, it’s in here” moment.

I guess I’ve always felt like big changes and shifts are “it’s in here” moments. There are lots of techniques and approaches to get us to those shifts, and a skilled coach, mentor, teacher, or counselor can help us to or through those shifts, but my moments of radical clarity have always come just bumping into life. It’s interview season right now, for instance, and I have been reminded of the “pouncer” and “stalker” learning styles. I think in life matters I’ve turned out to be a “pouncer.”

But I also think there’s value in spiritual community – even having a teacher – because to be raised in a liberal society in the 21st century is, regardless of your ideological tilt, to be coached toward profound egoism and a kind of selective sollipsism. Finding someone to trust and someone willing to work through our egoism and self-protection can be helpful. I know I’ve benefitted from it when I’ve been stuck on something, even if the benefit I got wasn’t a resolution, so much as an ability to sit with the discomfort of a lack of resolution.

I titled this post “What is practice?” because I’m not always sure. If I ask that question of a Soto Zen practitioner I’ll get a kind of answer. If I ask three Soto Zen practitioners, I will likely get three different answers. If I widen my survey to different sects, still more answers. If I ask the person trying to sell me a mindfulness app, there will be another answer, and since there seem to be dozens of those people, probably dozens more answers.

I think for now my working definition is “whatever grants you the most ability to sit with your thoughts and feelings in a place of remove from them, but engagement with them.” For some people, that will involve very austere forms – Al says at her Zen center you can opt in to a firm rod on the shoulder if your form slips – and for others not anything like that at all. I’m most in a “practice mindset” when I’m running, doing some kinds of writing, and playing some kinds of games.

Those aren’t buttons I can push – click I am running so I am correctly engaged with my thoughts and feelings – because I find myself sometimes a mile down the trail having been eaten by a narrative instead of understanding where a narrative came from – but they’re the most reliable cues to get to the right relationship.

So, I don’t know, I said I wouldn’t recommend that dome show. I suppose if you have a few Alan Watts books sitting around, or care to undertake some internet research and are careful to avoid what appears to be a recent trend of people making Alan Watts deep fakes that spout mysticism, you could sort of rig something up for yourself with headphones and a good screensaver. But it did remind me of a few questions about practice and mysticism I hadn’t thought about for a while. It did smell a little like weed in the dome theater, though.

I came across someone’s attempt to create an “AI Free” badge people could adopt for their projects, and decided that while I appreciate the sentiment, it is not actually helpful to anyone besides people whose position stops at “I don’t want to use code produced by an LLM.” That’s a fine position I take no philosophical issue with, but it doesn’t help people who come across my projects, which are plainly excluded from using that badge, to understand what it means to use them or interact with the code base if their position is not reflexively anti-AI.

I could take a sort of naive position of, “look, a repo on GitHub is just a repo on GitHub. There are no promises in this world.” And I’ve chosen the MIT license for everything, because it has such a “do whatever you want with this” vibe. But I got a PR on one of the projects, read it and the problem the user was trying to solve, and realized “oh, right, it’s a GitHub repo and even though Claude is signing all the commits, there’s an expectation here that the act of having this code in a public repo on GitHub sets with at least some people.” Making it worse, the PR tripped my “I don’t think this PR sounds safe, exactly,” instincts, which meant I had now incurred work by being unclear about what it is I am up to here.

The other thought that crossed my mind came from a conversation with a VP of UX years ago, when I told him we were struggling to make the CSS for our very oldest Puppet documentation work with recent design changes.

He asked me, “do you maintain those docs anymore?”

“No. And we say so.”

“Are the releases they cover supported anymore?”

“No. We mention that, too.”

“Can you still read the docs, even if the CSS is broken?”

“Well, it’s ugly and a bit distracting, but the content is there.”

“Good. Then it sets the right expectation. Let it serve as signal. You’ll probably get less complaints about it because you’ve made your position clear with the non-support message, and backed it up with obvious neglect.”

So instead I’m going to disable PRs to just foreclose on potential for misunderstanding, and also do my own version of a “Made with AI” Dubious Housekeeping Seal.

I’m going to also make a commitment to make my language about these experiments less twee:

I did not “work with the robots,” “ask the robots,” “torture a bot,” etc. I used an LLM, used AI, used Claude, etc.

Whether it shows or not, I am in some fairly serious internal discussion about what these tools mean, how we should use them, how/if there can be ethical use of them, etc. The spectrum of takes on AI covers a range of people I know, care about, and respect. It feels disingenuous and a little dishonest for me to use diminishing or faux naive language to describe what I’m doing here, as if to me it is a matter of idle amusement or something I don’t understand I should take seriously or be thinking about.

So, this is the new README edition. And once I resolve the issue the PR I got against one of the projects is resolved, I’ll turn off PRs: More signal.

Important consideration before using this code or interacting with this codebase

This application is an experiment in using Claude Code as the primary driver the development of a small, focused app that concerns itself with the owner’s particular point of view on the task it is accomplishing.

As such, this is not meant to be what people think of as “an open source project,” because I don’t have a commitment to building a community around it and don’t have the bandwidth to maintain it beyond “fix bugs I find in the process of pushing it in a direction that works for me.”

It’s important to understand this for a few reasons:

1. If you use this code, you’ll be using something largely written by an LLM with all the things we know this entails in 2025: Potential inefficiency, security risks, and the risk of data loss.

2. If you use this code, you’ll be using something that works for me the way I would like it to work. If it doesn’t do what you want it to do, or if it fails in some way particular to your preferred environment, tools, or use cases, your best option is to take advantage of its very liberal license and fork it.

3. I’ll make a best effort to only tag the codebase when it is in a working state with no bugs that functional testing has revealed. Tags just mean “seemed to be in working order.”

While I appreciate and applaud assorted efforts to certify code and projects AI-free, I think it’s also helpful to post commentary like this up front: Yes, this was largely written by an LLM so treat it accordingly. Don’t think of it like code you can engage with, think of it like someone’s take on how to do a task or solve a problem.

My past reaction to OmniFocus has traditionally been “no, get it away from me.” Some of that reaction is to the tool itself and some of it is cultural: I remember OmniFocus when it was a bunch of AppleScript meant to make OmniOutliner do unnatural things, and I remember the culture it came out of. And some of that reaction is from thinking it is just too much, but that “productivity wang overkill” is pretty much its most loyal niche.

So I didn’t like its chances. But I had Claude write a quick importer for me that turned all my denote-task tasks into OmniFocus tasks, and I was able to quickly get some production data to work with.

My sole objective was to see how amenable – despite all its gears, buttons, and blinking lights – OmniFocus would be to just giving me my river of tasks and then providing ways to filter the river down.

To be honest, pretty well. The tool to use to get to the base view is Perspectives, and you can make a simple one that just shows all your open tasks and lists due dates, tags, and parent projects. I added a group-by-date to give me “today, the next week, the next month, beyond” grouping.

For project view, there’s a Projects perspective that’s fine. I just dragged them all into order.

To clean up the view a little I just collapsed the inspector sidebar on the right and the … sidebar sidebar? … on the left. That got me pretty much the view I have in denote-tasks, which I’ve taken to thinking of as “the big dumb list view.”

I still think OmniFocus is probably overkill for me, but I have a new appreciation for its flexibility.

I also did this exercise with Things, which I’ve always felt more warmly toward.

It is not really able to do the Big Dumb List view because it wants to show you today, upcoming, and anytime in discrete areas. I prefer seeing today + upcoming in the same place because sometimes I don’t want to do a today thing right now and like just looking down the list for a one- or two-pointer I can pick off.

denote-tasks is pretty much “what I hoped to get with TaskWarrior but didn’t.”

Rather than using sqlite it uses Markdown files named using Denote conventions, with some extra metadata in the YAML frontmatter for priority, due date, and project associations.

I chose to use the Denote naming convention because it gives me a reliable index for making associations between normal tasks and projects and can be the foundation for subtasks at some point. That also means you can use it in the context of a normal Denote notes corpus and take advantage of Denote stuff like dblocks if you like.

I chose plain text instead of a database because you can just pop open a task or project and make notes in it, or link to other notes, or whatever. There’s a (l)og hotkey to drop a quick timestamped note into any project or task. I use it when I close a task out or have new context to add.

I do need to go in and straighten out some of the hotkeys, because it started life as an extension to another notes management TUI, but that got a little cumbersome and complex.

Either way, it’s very keyboard-centric: Hotkeys let you change priorities, dates, and tags from the task list. No need to open a metadata window or sidebar, which drives me crazy with a lot of todo apps. You can navigate the task list with j/k/gg/G.

There’s a plain old CLI, too, for scriptability and because I like having an alias that just pops out today’s todos without opening an app, but it needs a bit more work – the syntax is a bit mangled from going a couple of wrong directions.

I liked TaskWarrior’s conception of “contexts” but borrowed Things3’s “areas” to name it. You can filter by area at launch, so denote-tasks -t --area=work will open up the task list to your work tasks and projects.

And I liked TaskWarrior’s core UI: A big list. Partly because it feels grounding. A lot of task management tools hide tasks away behind whatever their organizational containers are (projects, etc.) and while I get that this is meant to be a calming design decision, it doesn’t work for my particular brain. I take a little of the potential sense of overwhelm out with a simple horizontal rule that underlines the block of tasks due today, and have filters for priority, estimate, tag, etc. so I can quickly narrow things down if I need.

It also has the core task states I tend to think in: open, done, delegated, paused, dropped. There are little visual indicators for those states, and the list is filterable by those, too.

Oh, there’s also fuzzy search and tag search. Great for 1:1s if you take the time to tag tasks with people.

So, I think mooooost people who are super into Denote would probably tend to just use org-mode for tasks. Moooost people who are into Denote would just tend to use Denote in the context of Emacs. I just really like Denote naming conventions conceptually, and like some of the portability baked into them and I don’t want to go live in Emacs right now. I’m still really digging Helix because since first setting up LSPs for it and doing basic configuration, I haven’t felt the urge to fiddle with it. Launches super fast, doesn’t need a daemon, does everything I want.

And denote-tasks does everything I want. I really wanted to like TaskWarrior, and like a lot of its ideas. But other parts of it were a little hard to swallow and there’s a ton of complexity there. This gets me the parts I liked, inflected to suit my particular mental model a bit better.

Oh … also I did this one with Claude Code as opposed to Claude Desktop. It is a lot more eager to take credit when it makes commits, and I think that’s a good thing. It’s fine and probably good if people know they’re getting code churned out by a bot.

Because I sit on my company’s AI governance committee, I have spent a lot of time over the past 18 months or so wondering what that button does in its many manifestations in all the apps where it appears. Sometimes it suggests some stuff you might want the LLM to do for you, like help plan a project, and other times it just does some sort of rewrite based on … ideas? … about “helping” you with your writing.

I know some ESL folks who like the pixie dust button when it stands for “writing aid,” because they want help with their writing. Because they’re on their second or third language, while they may not be experts about English they have a proven skill in language acquisition, so they’re not naive about what the button means. Not nearly as naive, at least, as people who speak one language and don’t give a fuck about that one, let alone any others. So they scrutinize the output. One of them consults unfamiliar words in the dictionary before accepting them, but appreciates the help with basic structure.

I also know people who want help with their effectiveness. Like the ESL people I know, they’re coming into that interaction less from the perspective of “I barfed some shit into a form and the robot made it good.” They’re coming at it with a use case like, “my boss is think-skinned, defensive, reactive, and mildly paranoid so how can I tell them something they don’t want to hear without triggering an episode?”

Having typed in what they want to say, then prompting for how they want to be received, when a more diplomatic revision comes out of the little pixie dust slot, they read it carefully, think about using it, then maybe massage it a little, or just use it as a suggestion. In other words, they apply their judgment, but benefit from the slight frame shift to imagine better alternatives.

One person I’ve talked to who uses AI in that mode has had a lot of success with the approach. It takes a little extra time because she never just copy/pastes the output, but it has gotten her good results: She truly struggled to express herself in a way that her thin-skinned, defensive, reactive, mildly paranoid boss could hear, and now she’s getting better outcomes in those interactions.

“I feel like I’m cheating,” she said. “Like I’m not doing my job.”

I said, “you’re a senior director for one of the largest Medicaid consumers in the state, and your job is to communicate effectively enough that your 100 employees can get shit done without you triggering a diplomatic incident or your boss losing her shit because you decided fuck it, she doesn’t need to like what she’s reading.”

So I don’t really judge the pixie dust button or the edits it sometimes suggests to be an unalloyed social ill.

It was in that spirit I clicked the Greenhouse button.

I was hoping it’d be something novel or different. Like, maybe it would offer some insight particular to this kind of writing, or would analyze my commentary for unconscious bias, or even warn me that I was about to commit a hiring practices violation to a corporate system of record. Instead it just mostly repeated my writing but replaced a few turns of phrase I chose very intentionally with more cliched ones that altered my meaning.

I don’t know how many hires I’ve done, nor how many hundreds of interviews I’ve conducted. Lots. Lots and lots. When I’m the hiring manager, I’m a close reader of interview notes. I pay attention. When I’m on someone else’s panel, I write carefully and want to be clear.

Today was the first day that I acutely felt the impact of AI fucking with two things I care about: Hiring and communicating. It took my words and Business Englished them into something other. It altered meaning, and to no good end. Nothing was more clear. There were no syntactical, grammar or punctuation issues to call out. It just, I dunno, blorped them. There’s no word for it. It didn’t, like, insert sexist slurs or generate a picture of a Black Nazi. It just sorta gnawed the input like a slobbery, toothless dog and left a saliva-covered pile of verbiage normalized to some inscrutable standard. It was sort of like how when you have shake reduction on a camera, you’re supposed to turn it off when you put the camera on a tripod because it counter-intuitively risks blur: Feed the LLM good enough English, just not statistically congruent English, and it’ll just sort of cock its head then spit on your sandwich because it’s supposed to do something when you click the pixie dust button.

So my mind went immediately to some recent examples I’ve caught go by in other parts of my job where someone was plainly hucking their shit into a form and pressing the pixie dust button. The tells were the tells we’re all learning to spot – the sorta flowery lilt, needless explication, and obtuse summarizing; the gratuitous length that reminds me of early efforts to use CG in superhero movies, where it’s just obvious that it’s CG because human bodies just can’t articulate like that, and would rip their own arms off or snap their own necks moving with that kind of speed. Like, nobody in their right mind, asked for a quick outline of a modified five step process you could fit on half a sheet of paper, would spend the time it took to extend that to five pages.

But as much as it was a waste of my time, it was easily addressed because it was obvious and gratuitous. The perp owned it, reminded me of their insecurities about writing, and agreed that they’d lost sight of the problem they were trying to solve because for a few seconds it felt really good to not struggle quite as much to make words come out. I don’t think it was meant to be a knife-twist that they said they fed it some of my writing as a guide.

And for a lot of business writing tasks, I worry less. If my helpdesk manager wants to send a quick nastygram to three engineers who won’t send back their old laptops because they’re too lazy to get their shit off of them and put them in the return box, I don’t care. “My director is going to tell your director, then he said I can lock that fucking thing and delete all your shit” is going to be clear no matter what the pixie dust button does.

But I benefitted from Puppet’s outstanding emphasis on interviewing and hiring a long time ago, and every detail of those things has mattered to me ever since. I’ll cut corners, let myself have bad days, fudge, procrastinate, take unwarranted mental health days, accidentally nap through the first 30 minutes of a QBR, and generally be a slob about a lot of other things, but interviews matter. Period. They’re an absolute. When I have one coming up, I pull my shit together and go do it. When I sense someone else isn’t invested, or they’re phoning in their feedback, or they didn’t pay attention during the kickoff, I judge.

Greenhouse provides a button to fuck with something that matters. A kind of writing that matters. It was just a stupid fucking five-pointer to some dev, plopped in the backlog by some product owner who might not even see the sense in it but knew they needed a third bullet for the AI features list, mandated by some director of product who got it loud and clear from someone above them that the market demands moar pixie dust buttons.

Anyhow, it was sort of clarifying. I’ve been a little paralyzed when I get the weird AI documents, because sometimes they’re non-objectionable. Maybe too long, or too wordy, or with odd little nuances that aren’t wrong but are off, but I ask myself “for everyday dumb bloodless business writing meant to detail a process, explain a system, or document some steps, is this okay?”

Usually yeah. It’s fine.

But this got me off the fence a little. I know some people like to announce total bans on AI assistance. I think that’s risking losing sight of some things, and I actually can’t because we’re under a mandate at work to use exactly the kinds of integrated assistance these things offer via all the Google Gemini integrations. (I did overhear a team mentioning that something they were given to work with by their leader would need careful review “because it came straight out of AI and probably has mistakes,” and that made me cringe.)

So I just told my folks that I’ve needed a reason to follow the thirty percent rule a little more, anyhow – ask for review when you think you’re thirty percent done – and that I want the 30 percent they put in front of me to be just them, not a bot. I just want to know they thought about the core of the thing they’re doing, and that they’ve chosen a direction we can discuss further if needed, before pressing the pixie dust button. If that runs afoul of the “use this shit” mandate, because we’re also supposed to be offloading our thinking, I’ll see ya on the soup line.

If I could burn that button out of Greenhouse though, I totally would.

Coda, bright spot: I listened to a C-level exec from a major software company say that the biggest challenge they have with AI features is that uptake is really poor. People don’t like a lot of it, or technology leaders are resistant. That sort of tracks with the tools I’ve got in my portfolio at work. AI was pitched as an expansion or upsell a lot last year. This past several months, three pretty big ones I manage just said “fuck it, you win,” turned the features on for me, and rolled them into the main SKU without charge. That’s some money and time down a hole.

I got so used to GNOME’s overview being under my thumb with only x percent of thumb curl instead of the pre-tweak y percent that the Framework 12 felt actively hostile. Now it matches my other Linux stuff and the slight change in the number of milimeters my thumb curls to invoke the overview/launcher feels like much less effort.

Now I’m eyeing the Mac Studio. It’s a first-gen M1 Max model and it is still going strong, but when I’m being realistic, my main tether to macOS is Lightroom, and my main tethers to Lightroom are a. it has 24 years of digital photos in it that and b. a few raw profiles I’d need to figure out how to replicate with another tool.

I like the occasional abrupt swerve into more Linux usage because it’s got that whole “slightly parallax world” thing going on. My mindset in front of a Linux machine is much less interested in hucking stuff on it than I’m willing to do with a Mac, and I’m less willing to keep stuff on it just in case. It’s a much more down to business or, at least, down to the task at hand mindset.

I remember being furious over the turn GNOME 2 took in the naughts, after Sun did a usability study and the team started unbolting shit and tossing it out the back of the plane. Years of configuration equity and tweaks went out the window overnight, and the project leadership just did. not. care. if you were mad about it.

Over 20 years later, though, when I sit down to a fresh GNOME instance where I haven’t yet had an opportunity to add “missing” features with assorted tweaks, I appreciate the mindset. It’s a very calm interface.

It’s not entirely the fault of Apple or macOS designers that macOS feels more and more busy to me these days. It’s that most macOS apps seem to feel entitled to taskbar real estate, so you spend a lot of time finding the “show in task bar” option as you realize your taskbar situation is out of control.

It’s clockwork predictable that after I set up a new Linux machine or start using one after time away I will go through my Macs and do everything I can to remove anything that detracts from a sense of a blank slate when I start a session.

If you asked me if, in the abstract, which desktop ecosystem would produce the more consistent, calm behavior on my part, I’d probably reason that the edge macOS has in uniformity would lead to more ordered behavior.

In practice, my Linux machines seem to be the more restrained ones, and a little time on one of them causes me to pare back the widget creep that happens on my Macs.

I wonder if some of that is that my formative years on Linux well preceded the iPhone era and the way it kind of “appified” the macOS mindset. Like, when I look at what’s in /Applications on a long-lived Mac, I wish my biggest problem was that I can never bring myself to drag Pages into the trash “just in case.” My biggest problem is that I’ve got a ton of unneeded single-purpose things it was easy enough to add and inoffensive enough to leave, letting the clutter pile up. I just don’t act like that on a Linux system.

It was off to a good start, though, when I just made sure I was in the right context in TW and got ready to dig in: task context:work filtered out the non-work stuff, and all my “today” stuff was red, with tasks from my current focus project in yellow. Very easy to be clear on what I’d committed to or what the best things to pull forward would be if I exhausted the day’s list, and it helped me spot things that I knew I’d need to rethink as I worked through the focus project and future tasks were affected by current work.

It’s one thing to sort of develop a model in your head and get it set up. It’s another thing to nibble around the edges with a little use here and there while you’re figuring out the model. It’s a completely other thing to have a long stretch of time in front of you where it’s just you and the system and an opportunity to do all the things with it.

So glad I took an axe to the default color scheme and made a much more simplified one. I felt pretty relaxed having only maybe four status colors to deal with for “today,” “next few days,” “projects,” and “all the rest.”

I’m glad I’ve taken the time to set up simple shell aliases to make some tagging implicit. It was easy to capture stuff as it came in via Slack, etc. and when I took a pause mid-day to triage some of the incoming it was easy to start from the bottom and retag/add to projects/etc. I’m okay with a very linear list of tasks with high resolution at the top and very little at the bottom.

I wasn’t sure how I’d deal with the wall of tasks I get when I have a minimal filter in place and run the basic list. But after a day of checking in with it, I realized I really like it: Yep, there’s a lot to do, but I do really poorly with tools that tidy things up, hide next steps, etc. I know GTD theory says “don’t try to keep it all in your head,” but I appreciate the reinforcement and feel less likely to have something languish because it’s out of sight, and I like the opportunity to make a random connection.

On that last point, for instance, one of the folks on my team shared some concerns about their career growth. I made the concern a task, because I owe a conversation about that, and I made it a p1 so it gets a brighter color treatment, and as I worked through a couple of strategic projects today, whenever I checked back in with my list, there was that bright orange, unscheduled p1 sitting down there reminding me that as I think about the big picture I’ve got to also pull some things into its wake. There are some things you can’t compartmentalize.

I think TW has some features that would allow me to get to a bit more of a “only see as much as you need to take the next step” state without losing sight of stuff, but one piece of meta awareness I’m bringing to this iteration is that leaving features on the table is healthy. The mental complexity people describe when they talk about their “productivity methodologies” always leaves me feeling skeptical that the system they’re describing is sustainable or helpful. One reason I’ve always appreciated Things in the Things/OmniFocus debate is that Things does a better job of sort of tucking away all the options unless you choose to use them. Maybe OmniFocus has improved in this regard, but it always felt more willing to expose all the knobs and dials.

So, great experience. I don’t have a ton of them next week owing to the compressed holiday timeline, but I do have a few stretches of time, and I’m already feeling a little less of the nervousness I feel when I see I’ve got some hours to fill.

I forgot I even ordered a tinyPod until it showed up at my door Wednesday. I ordered it a very long time ago. (Checked the mail after posting this: 10 months ago!)

It, uh, it turns your Apple Watch into an Apple Watch encased in plastic with a scroll wheel.

I think the logic of this purchase was:

• I don’t really like my Apple Watch as a watch anymore. I am wearing my field watch these days.
• It seems like a neat idea to have a little iPod-like thing with cellular connectivity.
• I like the idea of having access to things like calendar, weather, directions, etc. without having my phone along.

One could say, “if you’re getting all that utility out of the watch anyhow, one easy way to carry it would be on your wrist.”

Fair point!

In this case, I had just sort of moved on from wearing any kind of wearable and was back to my trusty titanium field watch, and I couldn’t bring myself to sell the Apple Watch because I doubted I’d get much for it. The <$100 I paid for the tinyPod meant I could have a little connected device that wasn’t a phone, and do something with the watch that I kept not selling.

I think the natural niche for these is probably “get a deal on a used Apple Watch, convert it to one of these things to have a smart iPod nano.”

Oh, details, I guess:

A few of the buttons are a little stiff/vague, but the main one works well enough. The scroll wheel is fine; though you sort of want the middle bump to be a clicker and it isn’t. The natural way to operate the screen is with your thumb and that works fine. There’s a cutout in the back so you can use your watch charger with it. It feels very nice and solid in the hand. They did a nice job with most of the design: It fits right in with an AirPods case.

I’d really like it if someone just made something like this that was a purpose-built connected smart device in a tiny, non-phone form-factor. There is some serious wasted space in this thing that could go to battery. In low power mode with all the health detection features turned off, it sips power. I think a solid week from a charge could be a reasonable expectation.

And the why is just “I don’t like carrying a slab around in my pocket, and I don’t like all the things that slab does, but I do want access to a limited amount of data now and then.”

A few years back I got into a habit I liked of just leaving my phone and not having it around the house, and leaving it behind sometimes when I went out for coffee or whatever. My job affords me some roaming and flexibility, and it’s nice to be able to go, “oh, when’s that thing I’ve got to be back at my desk for?” without having a phone to do that.

I guess it’s partly an esthetic thing, partly a bent kind of over-optimization, and partly contrarianism. I guess I like some of the things that smartphones allow, but sort of hate that smartphones continue to get bigger and do more.

Anyhow, I guess I have a tiny connected device that can do all that stuff now, and I don’t need to haul my phone around or have it to fuck around with when I’ve generally been happier when, sitting and waiting for my order, or for the movie to start, or whatever, I’m not doing anything but sitting quietly and thinking about whatever.

Okay. I guess I’m okay with this thing. Thank you past me. You were momentarily inscrutable and mysterious, but you made a good call.

I’ve got a pair of aliases that take away some of the wordiness of task entry: twa and twp for things that get either the work or personal tag. If I want to add metadata I can, but if I need to just dash something in, it’s fast.

I’ve set up a work context, a personal context (which is just not tagged work), and a contacts context. So it’s easy to cut away the noise from different areas of concern.

I customized priority to p1, p2, and p3 and I customized estimate to ye olde Fibonacci sequence.

I tried using the start/stop functionality and it created an overwhelming amount of visual noise, so I promptly quit doing that, and had such a bad reaction that I ended up radically simplifying the color scheme:

• red: overdue
• paleish orange: due next 48 hours
• yellow: active tasks, which by convention I am limiting to my most important project
• normal text: the rest
• cyan: a “project container”

On that last, Taskwarrior doesn’t really have subtasks. It does have dependencies and it does have projects. I’m not sure where I’m at on the lack of subtasks. Right now I’m feeling my way through. One way I’ve adapted is to make a task that I tag with project that states the outcome of the project. Something like “Turn off Otter Integration.” Then I set the date I want that to happen and tag it project as well as add it to, e.g. project:otter along with all the related tasks.

When I run the big task list report, the project deadlines/delivery dates all show up in cyan, so I can get a sense of relative timing of everything I have going on, or will have going on, and how much stuff is between me and getting that thing done.

I’m trying to be sort of roadmappy/backloggy about all this. I am trying to avoid prematurely assigning due dates until I feel pretty confident I can honor them, or until I’m getting close enough to “due” on a project that I better make a plan.

Since I due-sort everything on my lists, it means there’s sort of a pool of undated tasks down at the bottom of the report just bumping around. That’s fine. They’re the backlog. The meaningful action is the stuff to the top of the list with light color-coding for the stuff I’ve decided needs to happen right now. If I want to start more detailed scheduling on a given project, I can just run the list for it, e.g. task project:otter, and then assign due dates on as much as I need to keep going. If I want to go prospecting, I can run task undue to find things without dates.

I once knew an engineering director the project managers dreaded because he wanted to plan out and schedule the next six sprints in detail, then re-ripple the plan at every sprint close. Basically pantomime horse Agile, I guess, shoving Jira tickets around a board. It was tedious make-work in the service of a fundamental hypocrisy of the place we were working, which was that we’d “gone Agile” but weren’t at all Agile.

I am not making software. I’m just running an IT org in the middle of a pre-IPO tech company. That company has four or five processes for everything and has the usual struggles around alignment and prioritization that 600 people are going to have. A lot of deadlines are negotiable. The hardest deadlines tend to be based on contract cycles or compliance motions. So there’s no sense in me deciding I’m going to be utter death about turning off the Otter integration on time: It isn’t costing money, it’s just making Legal nervous and it’s annoying me. So planning it all out is pointless, unrealistic, and fussy.

On the other hand, there’s that one app I’ve been gunning for two years running, I keep missing the window to run a sunsetting motion, and this is the year for it. That requires some detailed dates.

I’m leaving some Taskwarrior stuff on the table:

It has a calculated “urgency” score that I have disabled on all the task lists and taken out of the color scheme. It’s information overload and I don’t need it.

You can make things active and inactive. That also makes more visual noise than adds clarity, though I am experimenting with making all the tasks in the highest priority project active and giving them a different color treatment so I can keep them in easy view.

There are dependencies. Yet more detail that I don’t need to manage. If I get into something so deep that I need to do dependency mapping, the staff program manager will probably be insisting she be allowed to get involved, and all that shit is going in Jira.

So I think what I’m left with is a task list that has some nice ways of storing task metadata (tags, projects, due dates, priority, estimation) without needing to manage fussy plaintext syntax: Taskwarrior uses sqlite, so while you need to type it in correctly, you don’t have to worry about an errant semicolon blowing up your carefully manicured plaintext todo list.

You can leave a lot of features on the table if you like, and everything is amenable to customization.

Tying into notes-tui

Today I spent some time working on integrating this with notes-tui, which is now mostly compatible with Denote, meaning every file has an identifier.

• I added a feature to notes-tui to open a note by identifier
• I added a custom data type to Taskwarrior to store a note identifier
• I added a command to notes-tui to create a Taskwarrior task storing the note identifier
• I have a wrapper script that lets me type tasknote 52 (or whatever task number) and open the associated note.

Tying into mutt

Likewise, I have a mutt macro that creates a task with the subject and sender and stores the msgid in a custom field in the task, and a wrapper script that finds the associated message for a task in mutt and opens it.

So today I made Monokai Pro Ristretto themes for mutt and Taskwarrior, and in the process discovered that there’s a business entity that licenses an icon pack and themes for a few editors. It grants an endless demo license or you can pay a few Euro to license it for your editor, so there’s not exactly a heinous money grab involved. If Monokai has been involved in cease and desists against terminal theme authors, feel free to inform me.

But I’ve been seeing Monokai, Monokai Pro, and the assorted variants around forever, everywhere, and never realized anyone was selling licenses. I’d be gobsmacked if any of the people shipping Monokai Pro themes (as opposed to plain old Monokai) licensed them for distribution. I get the impression the designer is happy to get a few euro for his efforts and more pleased to have made a thing that is literally everywhere.

Anyhow, I guess there’s sort of an applied ethics thing here, which is “now I know,” so I’ll keep what I came up with to myself and slide a few bucks to the designer, because Monokai and/or Monokai Pro has been a goto for me on every terminal app and editor I’ve used that supports it for a while, and the creator has signaled that he’d like some money for his work.

You can read about Monokai Pro’s history from back in TextMate days to today if you’re curious. I think if my theme had screen time on an episode of Silicon Valley I’d be jazzed, too.

I picked TW because it has been around forever. I will not presume to judge its design decisions. I can tell a few strategically placed aliases would do a lot to remove the sense of crushing overhead. I also picked it because it is super scriptable, so it was easy to build a tasks backend into my contacts TUI with it.

I decided, alongside implementing TaskWarrior support, that I’d probably better implement Things support. Of all the task management tools I’ve ever used, Things has been the most sticky, because it’s always lurking around whatever device from the last time I used it, and it is so easy to ramp back up. Whenever I pick Things back up again I collapse the sidebar and live in the Inbox list until it gets to the point I’m setting up projects again. So I added Things support in case TaskWarrior turned into a misadventure, as these things can.

The best way to describe my relationship to any task management tool is probably “anticipated decay” I never get into one thinking “this is it forever.” I know it’s going to follow a cycle:

• Tentative first steps, barely justifying its existence over a legal pad or Apple Reminders with just one todo list
• Creeping complexity: Projects, areas, tagging, subtasks
• Data entry simplification. If there’s a hotkey, widget, Raycast thinger or whatever, I’m all about it. This is always the beginning of the end. It really should not be easy to make work for yourself.
• Fully operational battle station. A sense of pleased familiarity when I review what’s in it each day.
• Minor vibrations and oscillations as priorities shift; increasing in intensity until I dread reviewing what’s in it each day.
• Collapse. I go into crisis for a few weeks and write a few hasty export scripts to at least remember what plates were spinning. Then I walk away.

Inevitably, somewhere between the “things are getting real with this thing” and the “I need to make the process of making work for myself buttery smooth,” the mobile or multi-platform questions rear their heads.

I imagine life without being able to consult my many deliverables from my phone and some unpleasant part of my personality sends a jolt to the pain and nausea centers, hitting the intersection of old work trauma and pigheaded nerd completionism.

The old work trauma is simple to explain:

My first well-paying job was for an online content play whose leadership utterly failed to anticipate the devastation of the dotcom bust in the early aughts.

When they hired me I was a recently discharged paratrooper splitting my days between running a database for a school and doing secretarial work. The pay was miserable, but my half of the rent came out to $250 a month so I spent my time screwing around with that database and getting called “four-eyes” by the kids who got sent to the office. I wrote a long comment about man pages on Slashdot that caught the attention of a Linux.com editor who turned it into an article, and that caught the notice of a website editor who offered me 3x the pay to come write a story a week, moderate comments, and keep a newswire site running.

So when the good times began to run out the next year, and the layoffs started, my little workgroup went from 15 people to just me in about six months because, I later figured out, “3x part-time database, part-time secretary pay” was still pretty cheap in the online content world at the time.

But I was terrified of losing that job. Terrified at the prospect of being laid off. I spent one nine-month stretch working every single day of the week. I got good at a very primitive sort of early 2000s mobile computing because if I wanted to leave the house on a Sunday afternoon, I needed to at least moderate comments from a device, somehow.

Eventually some things went really, really wrong with that place and I quit caring whether I kept the job or not, and I finally just left and went back to school, but I never really lost the habit of thought that some mobile access is very, very important.

When I pause for a moment and have a thought, I realize that is mostly ridiculous.

At work, I live on director time. I’m struggling mightily to imagine a scenario where I would need to know the details of some particular task on the spot, or where it would not be okay for me to say, “you know what, I know that’s in my tracker. When I get home I’ll Slack it to you.”

In my personal life, again, no. Groceries, I guess, but those go in Apple Reminders because we’re an Apple family, as do most little one-offs.

Someone, somewhere mightily disagrees with all this. That is fine. I’ve been reading about peoples’ assorted “systems” and “methodologies” for, like, decades. Everyone needs what they need.

And what I need is “less,” because my unchecked impulse is to optimize for things that I don’t need to optimize for just because I can, and because the correct direction for anything having to do with work and a mobile device is toward little more than “whatever I need to answer a management on-call page or do backup 2FA for Okta.”

So as I was fussing around figuring out the useful aliases to set up for TaskWarrior I had a brief “but how do I check tasks on my iPhone?” thought that yielded gratifyingly quickly to “I know there are ways, but just don’t allow for that use case this time.”

So I’m not.

There’s a tiny bit of friction in the system as a result, and I think that is fine.

I do some extra data entry: During the day I have a daily note with Markdown checkboxes for todos I acquire during meetings and 1:1s. I have a calendared reminder called “clear the decks” around five on weekdays that is my cue to sweep the tasks from my daily note into my task system, when I can think about describing them better. My notes tool has an “unchecked box” search I can use to make sure I haven’t missed a stray item.

This afternoon’s deck sweeping netted a few things that I shouldn’t have written down in the first place, and a chance to catch a pattern from reviewing the day that I missed in three separate moments during the day.

As with any CLI tool, a certain amount of practice is in order, so I’ve invested some time doing a lot of manual task entry just to get the basic syntax burned in. Yes, I briefly considered scripting an import, but decided to do it the hard way for the practice, so no AI-fueled moral hazard for me!

(While I was puttering around, I was briefly reminded of when I was a really big fan of the old Remind app, too.)

Anyhow, it’s been sort of interesting rewiring my brain around CLI/TUI tools the past few weeks. My sense of what it means for something to be discoverable, scannable, or legible has shifted a little as I’ve built interfaces that suit my particular sensibility about how to be keyboard-oriented. Things that initially felt a little opaque or closed-in have begun to feel more expansive.

I’ve tried to be mindful about how much time things really take, not just how long we’re sort of conditioned to think things take, or conditioned to believe are more easy or discoverable.

It led to a curious iteration where I got sort of tired of dealing with Emacs as an uneasy citizen of macOS, to deciding maybe if I pared back Obsidian’s UI a ton I’d be happier there, to wandering into my own notes app backed by Helix, where I’ve been able to define what is most legible and discoverable to me.

It is pretty nice to just fullscreen Helix in a kitty session, or split my notes into one Zellij pane and my tasks into another. There are some tradeoffs living that life, but it feels less cluttered.

Drop into insert mode, start typing wikilink brackets ([[) and it invokes autocomplete on every file in the directory.

Placing the cursor over a wikilink, you can use gd (go to definition) to open that file in a new buffer.

In other Helix progress notes, I briefly had a bunch of vim keybindings set up to quit stumbling over the evil muscle memory I picked up from Doom Emacs. Over the weekend, sitting in a hotel room waiting for a concert to start, I decided I wasn’t so proficient at vim that I should cling to it, so I got rid of them.

That is definitely making for a few mistakes here and there, but Helix isn’t that hard to pick up.

Other Helix stuff I picked up:

You can hack in Markdown auto-increment for unordered lists and tasks by saying they’re comments in your languages.toml file:

[[language]]
name = "markdown"
comment-tokens = ["-", "+", "*", "1.", ">", "- [ ]"]

… and this lets me check off Markdown tasks with spc x:

[keys.normal."space"]
x = [
  "extend_to_line_start",
  "flip_selections",
  "extend_to_line_end",
  "extend_line",
  """:pipe awk '{
    if ($0 ~ /^- \\[ \\]/) {
      sub(/^- \\[ \\]/, "- [x]"); print;
    } else if ($0 ~ /^- \\[x\\]/) {
      sub(/^- \\[x\\]/, "- [ ]"); print;
    } else if ($0 ~ /^- /) {
      sub(/^- /, "- [ ] "); print;
    } else {
      print "- [ ] " $0;
    }
  }'""",
  "goto_first_nonwhitespace",
  "collapse_selection",
  "move_line_down"
]

When I kick off the day with a daily note I like to check whatever I’m using for tasks to figure out the most pressing stuff, and it goes into a checklist where it’s not an official todo, just a priority I’ll keep seeing as I go in and out of the daily note to log stuff during the day.

It is a little disorienting to have a full-featured editor that launches so quickly without worrying about daemonizing it. I mean, micro is pretty full-featured and has some nice plugins, but at some point evil-mode won me over to modal editing and micro doesn’t do that. It’s got a remarkably flexible keymapping system, but not so flexible that you can go modal with it.

• Fast search for notes in either a configured directory or one named on the command line
• Tag search, either in-line (#tag) or in YAML frontmatter
• Open to-do search
• Hotkey to make a daily note of a given format
• Alternate note template. If you see the point in YAML frontmatter, it’ll do that. If you prefer “l1 heading from the title” it’ll do that.
• It does a very basic sort of Markdown rendering on its own for note preview, or you can configure it to shell out to bat, glow, etc. I am using glow because it has an option to edit a file under preview.

It works really well with Helix or other LSP-aware editors, because you can add the Marksman LSP server and have your own connected notes system with wiki-linking without having to adopt another app, like Obsidian, if you don’t want that whole ride.

This morning I realized there is an opportunity to integrate it with contacts-tui via tag searching, so I added a command line switch to search for a tag and launch with that tag search: notes-tui --tag=@label. On the contacts-tui side, I added a command to launch that search by tapping O on a selected contact.

Launching that tag search from contacts-tui, I end up in the notes app with all the related notes for that contact in view. I can cursor around, read the notes, etc. and when I ESC out of the notes app, I’m back at the contact record in the contacts app. Tap t and I get a list of open tasks for that contact in TaskWarrior, Things, or dstask.

Or do none of that, because both tools work fine on their own.

It kinda gives me the idea to move contacts out of its sqlite backend and just move to plaintext serializing for contact info, with ripgrep to manage contact search.

So a kind of nice thing about dstask is that with dstask #{note number} note you pop open $EDITOR in a Markdown note attached to the task. dstask is aware of any Markdown checklists inside the task note and blocks completion of the task if there are open ones.

That’s maybe bad for me because I am a compulsive subtask-maker with a bad habit of opening a task, loading the subtasks into my buffer, and just doing them all without looking back. So if I stick with it dstask may shape my habits that way.

For some annoying reason, dstask also barfs if $EDITOR has an argument, e.g. emacsclient -nw, and I found myself once again writing some kind of wrapper for emacsclient. That is not Emacs’ fault, but it raised the perennial question “when does $EDITOR come into play and do you need a whole-ass Emacs config for those times?”

So I think “your go-to for this used to be jed, which acts like Emacs where it matters.” But I’ve been using evil in Emacs for years now: If I want to keep my muscle memory between quick CLI edits and my whole-ass Emacs config, what I really need is something from the vi family.

It being 3 in the morning, I embark on a tour of modern vi’s, looking for some sweet spot of “nimble” and “feature-packed.” I burn through a few neovim tutorials and starter kits (nooooooope) before stumbling into a feud between neovim people and Helix people on reddit.

So around 4 I’m running brew install helix and going through :tutorial.

It’s pretty nice! It launches quickly. No plugin system so the futzmonkey sort of has to stay in its cage, but it’s very batteries-included. I found a tutorial for setting it up for Markdown that wasn’t overwhelming and helped me get a sense of how its config works.

It is not “just a batteries included vim.” It has its own keybinding grammar (subject/verb, not verb/subject), so after bonking my head on those changes a few times I cheated and lifted a few vimisms.

I guess I also went through a quick consideration of micro, but the CUA-style default keybindings confused me the way nano often confuses me.

I added integrations with TaskWarrior, dstask, and Things to contacts-tui this evening:

• Put a contact in a given state, the tasks backend creates a todo in your configured tracker with that contact’s label as a tag.

• The task view on each contact includes tasks with their contact tag. You can close them out from within contacts-tui with a note.

This bridges the gap between contacts-tui and my todos, which is pretty important to me: If I want to be good at keeping up connections, I need the reinforcement that this is a thing as meaningful to me as any other thing I’m willing to commit to a tracker.

The connection isn’t truly bidirectional: If I close a task in contacts-tui, it’s closed in the tracker. If I close a task in the tracker, it’s still open in contacts-tui, but there’s some incentive to just close it out there: When you do, you can include a quick note about the call, email exchange, followups, etc. to keep the system up to date. (The note you enter in contacts-tui gets added to the Things note when it closes, so you keep the information both places, fwiw.)

The task backends are pretty modular and follow a simple pattern with just three calls (make, find, close), so just about any CLI task tool or scriptable tool could have a backend.

I started with TaskWarrior last night out of curiosity. I’ve never really warmed up to it but it’s sorta the big CLI task tool. I like dstask a little better and learned how to use it through a bout of insomnia last night. But cold light of day thinking told me that when I go on these CLI kicks for productivity tools they don’t usually last, so I added Things support as the realist option.

v0.5.0 has all the new stuff.

I haven’t really liked social networking as a development. Sometimes I’d even say I mourn its existence. I used to have people with whom I shared a great email correspondence who abandoned that in favor of the Eternal Holiday Newsletter mode of Facebook, or the “oh, I tweeted about it last week if you want to look it up” of the assorted microblogging services.

The kind of conversation we can have at a BBQ you invited your high school friends to is different from the one we can have over coffee. The kinds of things I’d say to you on my front porch might even be different from what I’d say at the cafe.

So the net effect has been to have a higher volume of very lossy connections at the cost of some very meaningful and higher-fidelity connections.

As I get older, that has gone from something I don’t like to something I feel very concerned about. Alison is constantly on me to stretch before and after our morning runs because she’s right: I do not have the body that once came off a six-week layoff from a parachuting injury to run in the Ft. Bragg 10-Miler the first day I was allowed to run again. Likewise, as much as I have a few habits of thought I try to cultivate to keep from turning completely inward sometimes, there are some parts of the world that don’t become more comfortable to deal with as we age. Some days, my reaction to whatever is going on out there is to wish people would just shut the fuck up about it. I think that’s a fair, reasonable, understandable reaction, but I also think that’s not a great place to go live.

As much as I’m introverted, politely contrarian, and completely over some of the fucking takes I’m reading, I have to stretch. As much as there are some people I’d love to hear more and different from, at some point you just have to acknowledge that for whatever reason, those vibrant email threads petered out and are not coming back, so you have to replenish the supply of human connection.

During my unplanned sabbatical a couple of years ago, I realized I was going to need to settle in for a few months of being at loose ends while I figured out what was next and started to drum up opportunities. I knew I needed to network, and I also knew I needed to just interact with people. Left to my own devices, and without a plan, I knew I’d just go full introvert and I didn’t want to go full introvert.

So I set about leveraging org-contacts to build what I called the plaintext CRM: A bunch of functions that made it easier to keep in touch with people. The core ideas were:

• Different kinds of relationships need different kinds of attention
• It’s easy to lose track of a thread, so it helps to have some workflow management when you reach out to someone
• It’d be nice to have a log of contacts so you could remember where you left off
• It’d be nice to integrate this with org-mode so ticklers to ping people or follow up, or just mark a contact “timed out” would show up in my agenda each day.

I used it for plain old social stuff during my layoff, and also to track recruiter pings. It helped me feel (and behave) a lot less transactionally about reaching out to people, because while I did have a small pitchfork at my back to get out and network, it reminded me to follow up on social stuff as well.

It was a good system for where I was at, because I was living in Emacs, it was sort of a fun and stunty layoff project to implement something like that in Emacs, and I was able to stick to it because it was right there in my todo system.

Usage fell off once I was back at work and got busy again, which has bothered me on and off for a while now.

Several weeks ago, I fed the elisp to Claude as a proof of concept for an MCP. The repo for that is private because I did put it into production for a period and the security studies on MCP are a little dire. They’re just modulations on common security issues other protocols can present, but I’m not gonna lay bare my vibe-coded contact management infra.

The MCP itself worked as well as a chat-based interface can, and did what a lot of AI stuff does these days: Points to something that is both pretty cool and simply not there yet.

The pretty cool part was making Claude aware of my contacts database and the state of contact with everyone in it. During day-planning, I had it set up to check in on the state of contacts and drop a few pings, followups, or calls into my calendar for the day. That was a small proof of concept for MCPs as a kind of executive assistant.

The parts that were not there yet:

• It’s a slow interface. An MCP is just API calls, which are fast enough over a local network and hitting a sqlite db, but there’s some overhead to get an LLM to invoke the tool, interpret the results, and do something with them.
• It’s a lossy interface. I spent a few iterations tuning instructions to get Claude to do the right thing with certain language, but there was still an element of the one-armed bandit effect: Make a comment the wrong way, and Claude would add to a contact’s note instead of recording an interaction, for instance.
• It’s an opaque interface. Some of the better MCPs include some kind of CLI component so you can directly manage their state. I was stuck with telling Claude to change this or that thing once I realized it had done something I didn’t like – a whole lost several minutes to “show me what you did; change what you did; no not that way – this way.”
• It’s a bad idea to let an LLM near this kind of information.

On that last point:

You see people advertising their MCPs as “running locally and completely in your control.” Well, okay, but what the LLM is doing with that data is not completely in your control. What the LLM’s owner is doing with that data is not completely in your control. And for a homebrew sort of hobby implementation of a new protocol in a fast-moving technology, you’re assuming extra risk.

Second, I’m just curious, not completely obtuse. I want to learn about these things – work actually requires me to learn about these things – but there are people with heartfelt, sincere, thought-through objections to the AI industry whom I know would not like that even innocuous data about them is being fed into an LLM maw. I’m sorry I picked a project that involved that. I stopped at “actual need and well-understood problem” and didn’t think past that.

So I took the MCP down, which left me a little frustrated: I really did not want to go back to managing contacts in Emacs, and I really do not like any of the alternatives I’ve found for contact management: Finding the sweet spot of actually managing contact information and also managing the workflow of interacting with contacts has been a little hard.

So I teed up one last session with Claude to use the existing MCP workflows, data structures, and actions and turned them into a Go TUI that just repurposed my existing sqlite-hosted data into a database on my local disk. It does pretty much what my original elisp implementation does, but it’s written in Go so it’s a compact binary (and Claude is sort of a Go prodigy compared to experiments in Typsecript, Ruby, and bash).

I’m pretty happy with what I got:

• It’s fast.
• It does all the contact lifecycle stuff I used to do in Emacs.
• It adds the ability to define a custom cadence and style for some individuals, because there are folks you don’t need to reach out to much but if you see they had a nice life event or career development, it’s good to drop in a reminder to ping them with congratulations (or condolences).
• It has hot keys for most interactions, so there’s not a lot of cursoring around the interface.
• It has some nice state-setting and filtering hot keys: Quick to find overdue contacts, filter down to family, friends, or professional network.
• It has archiving, so for that one recruiter from a few years ago at the place you walked away from, you can get them out of the contact management cadence but keep the context for later, just in case.
• It’s completely local and un-networked. Not only is everyone’s data not going into the LLM maw, it’s not getting sucked in by anyone else trying to build their graph on your friends’ data.

This version is publicly available and pretty easy to build and install on a Mac, at least:

pdxmph/contacts-tui

There are a few features mentioned in the docs for creating a fixtures db you can kick the tires with, or just onboard with a blank db and start using it. There is no contact import tooling. Given the simplicity of the sqlite backend, it’d be pretty easy to lash up a CSV importer, and iirc it is not terribly hard to write some AppleScript to do that from the Contacts app or from a format like VCF.

I’m not sure it solves anything for anyone else the way they’d like, but it hits an intersection that’s useful to me by creating structure to be better at something I often neglect and wish I did better.

• An MCP for Remember the Milk
• An MCP for contacts management

I haven’t read a lot of commentary on how to code with AI, and I’ll say a little more on the kind of AI-related commentary I have read in a bit. Instead, I just let myself stumble into the challenges and try to figure out my way around them. The biggest ones were:

• Session length. Once either project got into complexity, the amount of progress I could make in a session slowed down. Claude would end conversations for going on too long in the middle of a debugging session, and all the context would get dumped.
• Context preservation. If you have to chain together a series of sessions to get one feature done, then you need some way for Claude to remember what it was up to.
• “Behavioral.” Sometimes Claude does dumb or misguided things. Describing them would be as fun for you as making you listen to me talk about a dream I had, so I won’t.

So as I’d pick up on a problem, I’d look for a way to address it, and largely landed on:

• User preferences that stress collaborative testing, step-by-step examination of a problem, and limited ability to move on until the user has said it’s okay to move on.
• Specific project instructions that explain what the sources of truth are, where the local code lives, how to go about selecting what to work on, and further reinforcement that we don’t write scripts to test scripts that test the code, etc.
• Reliance on continuity tools of some kind.
  • Markdown notes of what it has gotten done so far, what it needs to know to return to work on a problem, etc.
  • Continutity notes in GitHub issues, so it can pull the original issue, then record and catch up on its own progress with comments on the issue.
• Remembering to explicitly dig out API docs and include them in the prompt with little nudges: “I see a parameter asking for a location id …”
• Continuity prompts: “You were doing this, you recorded progress here, as always you can read about this entire project here.”

Luke sent me an article that very thoughtfully dissected this process:

“… the people I’ve seen most excited and effective about agentic work were deeply involved in constantly correcting and recognizing bugs or loops or dead ends the agent was getting into, steering them away from it, while also adding a bunch of technical safeguards and markers to projects to try and make the agents more effective. When willingly withholding these efforts, their agents’ token costs would double as they kept growing their context windows through repeating the same dead-end patterns; oddities and references to non-existing code would accumulate, and the agents would increasingly do unhinged stuff like removing tests they wrote but could no longer pass.

“I’ve seen people take the blame for that erratic behavior on themselves (‘oh I should have prompted in that way instead, my bad’), while others would just call out the agent for being stupid or useless.”

… then turned it around:

“It may sound demeaning, like I’m implying people lack awareness of their own processes, but it absolutely isn’t. The process of adaptation is often not obvious, even to the people doing it. There are lots of strategies and patterns and behaviors people pick up or develop tacitly as a part of trying to meet goals. Cognitive work that gets deeply ingrained sometimes just feels effortless, natural, and obvious. Unless you’re constantly interacting with newcomers, you forget what you take for granted—you just know what you know and get results.”

“By extension, my supposition is that those who won’t internalize the idiosyncrasies and the motions of doing the scaffolding work are disappointed far more quickly: they may provide more assistance to the agent than the agent provides to them, and this is seen as the AI failing to improve their usual workflow and to deliver on the wonders advertised by its makers.”

Phil Agre wrote about this years ago: “Most user interfaces are terrible. When people make mistakes it’s usually the fault of the interface. You’ve forgotten how many ways you’ve learned to adapt to bad interfaces.”

Both the contacts MCP and the Remember the Milk MCP were easy assignments: The contacts MCP just keeps a sqlite database and operates under some rules about when to nudge the user to check in on a contact and what to do when the user reports a contact. The RTM MCP takes advantage of a comprehensive, mostly straightforward API, mapping each tool to an endpoint with a pretty obvious purpose.

I won’t go into a ton of detail about the bad derails that still happened. The content of those derails is less the point than the simple fact that over a couple of weeks of evolving a pretty elaborate set of rituals to avoid memory issues, session length issues, and behavioral issues, there was still always a nagging sense of “when will this go wrong and how?”

For instance, the underlying Claude service itself is flakey. After a while I’d developed a pretty good sense of when a conversation was going long, but every now and then I’d get two or three messages into one – right at the point where the furniture had been rearranged in some function – and get a session length error. There went the context and all the sources of truth were out of sync with the code base.

Or it’d report writing the continuity note but truncate it. Or, or, or.

A boss of mine once said about an early scripting effort of mine, “it’s not that the bear dances well, but that it dances at all.”

That’s sort of where I’m at. In the end, I agree with this:

“… what is imagined is powerful agents who replace engineers (at least junior ones), make everyone more productive, and that will be a total game changer. LLMs are artifacts. The scaffolding we put in place to control them are how we try to transform the artifacts into tools; the learning we do to get better at prompting and interacting with the LLMs is part of how they transform us. If what we have to do to be productive with LLMs is to add a lot of scaffolding and invest effort to gain important but poorly defined skills, we should be able to assume that what we’re sold and what we get are rather different things.”

“That gap implies that better designed artifacts could have better affordances, and be more appropriate to the task at hand. They would be easier to turn into productive tools. A narrow gap means fewer adaptations are required, and a wider gap implies more of them are needed.

“Flipping it around, we have to ask whether the amount of scaffolding and skill required by coding agents is acceptable. If we think it is, then our agent workflows are on the right track. If we’re a bit baffled by all that’s needed to make it work well, we may rightfully suspect that we’re not being sold the right stuff, or at least stuff with the right design.”

… because as I painstakingly evolved my “get working code out of this thing” workflow, there were two things on my mind:

• Learning how to write all this for myself would keep me from having the tool I’ve imagined any time soon.
• If I’m sitting here in my living room working through this process with these readily identified limitations, other people who are starting from a place of more sophistication and more ability to do the meta-work of hiding all this tool-building I’m doing will probably be getting on that. In fact, they are. I added an MCP called “vibe check” that arrested a few spinouts before they happened by making the LLM ask what its original prompt was before it does anything. The number of memory persistence MCPs is growing.

On that latter bullet, I guess this puts me on the vaguely optimistic side about all this: My Brompton is a great implementation of a bike. Penny Farthing bikes are – given all we know today – a terrible implementation of a bike. If I tried to do an eight-mile ride downtown on a Penny Farthing bike, I’d say “bikes don’t work for commuting shortish distances.” With the Brompton, on the other hand, the gearing is excellent and does a lot to offset those 16” wheels. It’s fine for six or eight miles. Given the kind of Schwinn I had in grade school, with a banana seat, a big lever for a shifter, and high handle bars for that cool chopper look, I’d probably say “bikes aren’t great for commuting medium distances, but are fine for a spin around the neighborhood, and I can see how a few design changes could make them better.”

The metaphor breaks down quickly the second you shift out of “does it work” questions and move into asking “what is the return given the consumption of resources?” whether that’s electricity, water, developer hours lost to correcting spinouts, support tickets, or the human toll of inevitable misapplications at all levels of society.

The one-armed bandit

So, I’m glad to be sitting here writing instead of sitting on top of Claude, waiting for it to invent a non-existent API call, forget that a given parameter is an id and not a string, crash and burn with a partially edited private function I hadn’t realized was in there, or take it upon itself to push a broken image into production.

My two MCPs work pretty well, harmonizing with each other the way I hoped they would, giving me a conversational interface into personal planning that does a good job of “remembering” stuff and getting it back in front of me when I need it to. Claude itself has written READMEs that vastly oversell what it is accomplishing, because it has never met a project it has worked on with anything other than intimations of brilliance and completeness.

I had a good experience working on these things in a few ways. I got working tools, learned a bit more about what the tech is good for and not, and just as I was deep in the process, MCPs flared up as a security topic at work. It was very, very useful to be able to listen patiently, knowing something about how these things work, and have a useful opinion or two about how to characterize the risk they pose.

During this period, there was no avoiding The AI Discourse, and that was less fun. The discursive environment is up to the same shit it is with everything, and my deep annoyance with rhetorical moves that involve psychologizing people with whom we disagree has found no relief.

But for as much as the experience was edifying and interesting, the image that kept coming to mind was a slot machine, or a video poker game.

I once ended work early during a week in Las Vegas, gave myself an allowance to try gambling, and had a pretty terrible experience with it all. Years later I read that humans are succeptible to gambling addiction because we’re very inclined to seek patterns, and very inclined to misinterpret things as patterns, and easily unhinged by rewards we believe we can unlock if we just figure out the pattern.

If you’ve never gambled but have sat up all night trying to beat that one boss, getting worse and worse at it as you get more and more tired and frustrated, that’s sort of how a bad session with Claude felt, because yes, these things “work,” but for particular definitions of “work” that have to include the derails, setbacks, workarounds, constant vigilance, and ever-present awareness that Anthropic, OpenAI, Google, or whichever could twist some tuning screw down in the clockwork and alter the thing’s operating model in a way that throws it all out of sync, creating more digressions to unwind.

In the end, that level of engagement with the toolmaking tool to get the tools I was trying to make was sort of exhausting. I kept thinking of Bill Murray in Groundhog Day, waking up every morning to Sonny and Cher, wondering how far I’d make it.

Funny enough, Claude itself sort of pointed that out to me, because a few weeks ago I added something to my user preferences called “Focus Guardian,” which is a set of directives to catch me spiraling on stuff that is not what I want to spend my time on. Diving into yet another session to add just one more feature, with all the uncertainty of whether it’d be a quick walk in the park or a long slog, the focus guardian protocol kicked in and asked “are you doing this because it furthers one of the things that brings you joy or because you’re curious about some new tool or over-optimizing? Is there a writing project you could tackle instead?”

I guess AI “works.”

I set a goal of getting enough functionality in the MCP right away to start using the MCP to help manage development by keeping the project backlog in it.

And my long-term (for as long-term as “get this done before lunch” can be) goal was “get this into a place where I can use Claude’s connection to my calendar and RTM to do a planning session.”

A couple of things went well, a couple of things did not:

I did a test implementation of an MCP for Things last night. It went really quickly because the Things scripting API is pretty simple overall, until it didn’t go quickly because there are blind spots in either the Apple Events (Applescript/JXA) or URL scheme APIs. But a lot of time was eaten up by the fact that Applescript APIs are a bit more opaque to Claude than a published API. RTM on the other hand, has a pretty thoroughly documented one that Claude was able to grok in one shot most of the time.

I set aside the Things implementation because RTM is, overall, a more feature-complete tool, and its mental model is a bit more like mine. I think when I got to the part of the Things doc about prioritization that read sort of like a climb-down from an orthodox position, I felt a little impatient.

So, getting the foundations layed in for RTM worked well.

At one point, my very methodical approach to keeping project context intact worked against me, because I let Claude pick what to work on next and it rabbitholed on something it had done, but hadn’t marked as done in the project todos, because I have pretty rigid Project Instructions to keep things focused on preserving context. It managed to exhaust its chat length spinning out, left some half-complete work in place, and it took a lot of screwing around to sort out the damage.

At one point mid-morning the Claude API started getting irritable and dumped a few chats mid-session. I downshifted from Opus to Sonnet and that helped it move faster, but at the expense of having to get very controlling about its test cycle and occasionally needing to go look up API calls and explain them to it.

But by lunch time it was pretty far along. Far enough along that I set up Project Instructions for a personal organization project that:

• Allows Claude to work with my Google calendar and RTM to examine priorities and figure out good start times given my time estimates
• Catch when people, tasks, and meetings intersect, flagging those for a daily note
• Create Markdown project notes out of projects I have it create in RTM so I’ve got a place to hold more context
• Reprioritize, defer, flag, and remove assorted tasks

I’ve tried a few variants of this kind of workflow over the past month with different tools and approaches, and this is the most fluid I’ve managed to get it, combining calendar access, a todo app, and an LLM with structured guardrails on what goes where and what does what.

In the background, I’ve woken my plaintext people relationship manager idea back up, because once I realized MCPs are not the most complex things on the planet, and that I’ve got a working way to talk to an LLM about things I need to do, it’d be pretty simple to move the contact management workflow into sqlite for state, and delegate the contact workflow to whatever task backend I want to use. The last time I came at this idea I felt pretty sharply at odds with other peoples’ ideas of what a good contact manager on the Mac is for what I want to keep track of.

Anyhow, here’s the MCP. Just a hunk of Ruby with a script-driven OAuth onboarding workflow. I mean to just live with it for a while and see how it goes.

LR CC does offer one out, though: It has this idea of “Connections,” of which there are very few. One of them happens to be SmugMug. So as I ponder whether I want to stick with Lightroom as my DAM – and I am leaning against, but feel very fluid with it as an editing tool – I realized I can save a tiny bit of the wasted motion Lightroom’s blinkered refusal to participate in a normal “share this image to these desktop endpoints and services” by using imgup to not just push up to backend storage services, but pull from them as well.

So I’ve added pull to its list of things it can do as a cheap and cheerful way to squirt a few images from Lightroom up to a SmugMug album, then make a post from the CLI.

imgup pull takes a few arguments: the number of images to pull, any post text you care to add, which storage backend, which album on that backend, and which destination social media services (Mastodon or Bluesky right now).

So:

imgup pull 5 --service smugmug --album "uploads" --mastodon --post "Pictures from the show"

… will trigger a pull from the last five images. If you’re using a plain old terminal, you get a list of image filenames and the description metadata if you took the time to add it at some point. Pick the index numbers of the ones you want to post and imgup will make a post to Mastodon pulling in the tags from each image.

If you’re using kitty and set kitty_thumbnails": true you get thumbnails to help you make the right choice.

If you leave out the --post switch, you get the same list and can make your selection, and imgup generates JSON and opens it in $EDITOR. There you can add the post text, tweak alt tags, etc. before closing the file, which pipes it back in for sharing to Mastodon or Bluesky.

pull has one other thing it can do, which is filter by tags with the --tags switch.

v0.12.0 is up on GitHub.

If you use Homebrew, the easy way to get it is:

$ brew tap pdxmph/tap
$ brew install --cask pdxmph/tap/imgupv2

I pushed out imgupv2 0.9.1. It’s what I’d call feature complete:

• multi-image posting to Flickr, Smugmug, Bluesky, and Mastodon
• world’s crabbiest, most indifferent caching strategy
• GUI for posting straight from Apple Photos or Finder selection

I kinda like where it ended up with multi-images from the command line. They were super clunky using standard command line switches and positional arguments, and I think that’s a weird use case for the command line, but it’s a normal use case for automation, so the tool biases in favor of machines talking at each other in those instances:

# Create JSON and pipe it
echo '{
  "images": [
    {
      "path": "/path/to/image1.jpg",
      "title": "Sunset",
      "description": "Beautiful sunset",
      "tags": ["sunset", "photography"],
      "alt": "Orange sunset over mountains"
    },
    {
      "path": "/path/to/image2.jpg",
      "title": "Moon",
      "description": "Full moon",
      "tags": ["moon", "night"],
      "alt": "Full moon in clear sky"
    }
  ],
  "social": {
    "mastodon": {
      "enabled": true,
      "text": "Some photos",
      "visibility": "public"
    },
    "bluesky": {
      "enabled": true,
      "text": "Hello, thirst-trap bots."
    }
  }
}' | imgup upload --json

The GUI poster is sort of nice: Little thumbnails so you can catch it if you meant to upload from Finder but have Photos selected (and v/v), and while it won’t force you to add alt text, you get an affirming little green check if you add it to each of your multi-post images so that you don’t have to go back and check.

The caching thing … it’s okay. Basically, you upload something and its URL and some metadata get written into a sqlite db, so if you ever try to upload the same image again, you just get your snippet back without a duplicate. If you delete the image from SmugMug or Flickr, you’ll just get a broken image link in your clipboard, so if you’re a volatile Flickr or SmugMug user, just:

imgup config set default.duplicate_check false

And it’s installable with Homebrew:

brew tap pdxmph/tap
brew install --cask pdxmph/tap/imgupv2

… assign the imgupv2-gui.app a keyboard shortcut from Shortcuts or FastScripts or whatever you care to do and invoke it on a Photos or Finder photo selection.

But part of the reason for getting rid of almost all my social accounts was frustration over seeing things go by and rinsing/repeating the whole “someone is wrong on the internet” cycle, except I’m way too retiring to do anything other than delete the post or turn it into a homeopathically vague subtoot. “If a tree falls on Jupiter and nobody is around to hear it” levels of vague.

But having picked up and stuck to an atomic writing practice over the past few weeks, I have taken to just letting myself feel my first reaction and commit it to a note that I might drop a few tags into if I have recently written notes about similar things, and I then I keep going with whatever I was up to. The impulse to “say” something is honored, I waste no time crafting it down to a mild subtoot, and it’s actually better for later thinking, because it’s way easier to process a very brief, unfiltered observation than it is to process an overcooked one. The atomic note is just a hunk of raw ore for later.

One piece of advice I gave myself this time around was to not think about how all the notes would hang together, but to just write, tag a little, and periodically link back to the top of a topical tree or nearby note, not in a rigid folgezettel kind of way, but in a “this is part of a cluster” kind of way. I will not have a very awe inspiring graph view. That’s fine. This is more of a mental health exercise than a “walk in the footsteps of Luhmann” exercise.

Years ago when I was first learning to write scripts, I’d come up with stuff that made my life much better and would have helped other people on my team, and I’d run into the kinds of distribution problems you’d expect: I was a Linux/Mac guy, everyone around me was a Windows person, etc. I am guessing the 20th anniversary of the first time I said “well, it runs on my laptop” is right around the corner. Even people who could download the OSAX I was using for an AppleScript weren’t necessarily interested in doing it.

I learned Sinatra and HAML because I wanted to make work I was doing accessible to other people, and the best way to solve the distribution problem was to just build a web GUI and plumb all those Ruby scripts in as controllers.

When I wrote the first imgup, I did it in Sinatra and got it going on Heroku well enough that I could document how someone else could grab the source and run it for themselves. When I decided to pivot it into a command line app, the distribution problem came back, but I’ve learned enough over the years that if there were any issues with someone else using the code, I can’t really blame it on distribution woes, just my own disinterest in a test matrix bigger than “the OS running on the machine I am testing on.”

So after deciding to quit futzing with imgup – that it was as done as it can be – I started writing a blog post about the experience of doing the migration from Sinatra/Web to a command line tool using Claude.

The development loop I landed on over a few weeks of intermittent fussing had come down to leveraging the Basic Memory MCP to preserve more project context between sessions, and to chain project context with a special project architecture note in Basic Memory and what I came to call “continuity prompts.”

Basic Memory is just an archive of Markdown/YAML files kept on your disk with light markup to create persistence: You can annotate Basic Memory notes with “Observations” and “Relationships” that it uses to build a graph out of notes.

Observations look like:

- [architecture] Direct API metadata is cleaner than file embedding
- [performance] Removing exiftool dependency significantly improved upload speed
- [simplicity] Upload-then-set pattern is more maintainable than metadata embedding
- [consistency] Aligning Flickr with SmugMug's approach simplified the codebase

… and they work, to the extent that when I would turn on Extended Thinking and watch Claude talking to itself, it would mention them as things it “knew” or was trying to take into account when working on a chunk of code.

My Project Context note provides all the things Claude needed to know to start each session without going through rediscovery each time we worked on a new feature or bugfix. I devised a continuity prompt that reminded Claude to check out the project context:

I'm working on imgupv2, my fast image uploader for photographers. Please read the project context first:

memory://imgupv2-project-context-working-preferences

Key reminders:

- The GUI is Wails (Go + Web), NOT Swift
- External dependencies need full paths (GUI apps don't inherit shell PATH)
- Always ask before making changes
- Work incrementally and wait for confirmation

The Project Context note includes things like:

### 1. CLI Binary (`imgup`)

- **Location**: `/Users/mph/code/imgupv2/cmd/imgup/`
- **Binary locations**:
  - Development: `/Users/mph/code/imgupv2/imgup`
  - Installed: `~/go/bin/imgup` or `/usr/local/bin/imgup` or `/opt/homebrew/bin/imgup`
- **Purpose**: Core upload functionality, authentication, configuration

### 2. GUI Application (`imgupv2-gui.app`)

- **Location**: `/Users/mph/code/imgupv2/gui/`
- **Technology**: Wails (Go + Web frontend, NOT Swift)
  - [architecture] GUI uses Wails (Go + Web frontend), NOT Swift #imgupv2 #wails (correcting common misconception)
- **Frontend**: `/Users/mph/code/imgupv2/gui/frontend/` (HTML/JS/CSS)
- **Features**:
  - Detects selected images from Finder/Photos.app
  - Metadata review before upload
  - Mastodon integration with dynamic form
  - Seamless white window design

and …

## Project Structure

/Users/mph/code/imgupv2/ ├── cmd/imgup/ # CLI entry point ├── pkg/ │ ├── services/ # Service implementations │ │ ├── flickr/ # Flickr client │ │ └── mastodon/ # Mastodon client │ ├── config/ # Configuration management │ └── metadata/ # EXIF/metadata extraction ├── gui/ # Wails GUI application │ └── frontend/ # Web frontend (NOT Swift!) │ └── dist/ # Must copy files here for build ├── homebrew/ # Homebrew cask definition ├── build-macos-release.sh # Release packaging script ├── release.sh # GitHub release automation └── build-and-release.sh # Complete release automation

That is, btw, a Go project. Because in the midst of writing up my notes about what I learned working with Claude, I realized ways in which I’d made a very useful workflow that would have saved me a ton of time doing what should have been a simple migration of some controller logic out to a command line script, and that if could use Claude poorly to get a mostly okay reimplementation in a language I know, maybe if I used it well I could get a good reimplementation – and a more portable, accessible one – with a language I don’t know so well.

So I started with a clean slate, started a new Claude “Project,” and set out to make imgupv2 in Go using everything I learned to work with Claude and the Basic Memory MCP.

I would have been happy to just have a distributable binary I could share, but the approach I took to the whole thing let everything move super fast. To the point imgup can be installed with Homebrew, and ships with a little (optional) popup GUI so you can just select an image in the Finder or Photos, invoke a Shortcut with a hotkey. Its backward compatible with the old Ruby version, so it can be wired into anything you’d care to script, like Raycast Script Actions or Hazel folder actions.

I also added some new features because the core feature set went in fast. Oauth registration with Flickr, SmugMug, and Mastodon works without pasting URLs, etc. because imgup config fires up a little callback server duing onboarding. And after Jack Baty mentioned wanting to customize another little flickr script I had come up with, I added snippet templating:

  "templates": {
    "html": "\u003cimg src=\"%image_url%\" alt=\"%alt|description|title|filename%\"\u003e",
    "json": "{\"photo_id\":\"%photo_id%\",\"url\":\"%url%\",\"image_url\":\"%image_url%\"}",
    "markdown": "![%alt|description|title|filename%](%image_url%)",
    "org": "[[%image_url%][%alt|description|title|filename%]]",
    "url": "%url%"
  }

… so instead of living with my particular idea of how an HTML snippet should look, you can roll your own and override the default.

I also added accessibilty prompts and support (you get a reminder if you don’t specify an --alt flag, but the snippet will degrade from alt to the image description to the image title when making a post.)

… and I successfully used Claude itself as a sort of consultant. I was miserable about the way I’d added flickr support because it was dog slow due to my own limitations, but I was able to use Claude to reimplement flickr uploads in a way that makes them super fast and removes external dependencies on exiftool: I told it the pain point, which involved extracting images, writing them out to disk, and embedding the metadata from Photos then uploading them; and it suggested a pair of API calls: One to upload the image, and one to write the metadata over the API.

And the last “feature” is an automated build and distribution pipeline, complete with Apple notarization. One build script compiles the macOS and Linux binaries, signs the macOS binaries, builds the GUI, tags a release, and updates the Homebrew cask:

brew install --cask pdxmph/tap/imgupv2

… but also just …

go install github.com/pdxmph/imgupv2/cmd/imgup@latest if you don’t care about the GUI or want to build something in Raycast, Apple Shortcuts, Alfred, etc.

But why tho

Just curiosity, I guess. AI is a big deal at work right now, and my job puts me in the middle of a lot of it: Working through security issues, thinking about how to onboard and configure the flood of new AI features rolling out from all our vendors, and lately helping out with a training program. Our product is going to be using AI a lot more in the coming year.

There are a lot of folks around me at work who have a lot of takes, good and bad, realistic and unrealistic. One person scoffed, “I tried to get AI to write a program for my kids and it couldn’t! Smoke and mirrors!” Plot that take on a skepticism -> credulity bell curve, and I can probably think of equal and opposite occupants on the other end that I’ve heard.

Up until this past month, I’d mostly used LLMs as a coding augment. When I was writing the first, Sinatra-based imgup, I struggled with the syntax for building and tearing down OAuth sessions in Ruby, so ChatGPT helped me out there. I did a few proofs of concept for things like “write some Ruby that uses the TriMet API to tell me when the next three trains are due at my Max station” just to understand how it worked and what it could do. And if I’d come across an error, I’d use it to paste in the error, provide a little context, and get something as serviceable as a direct visit to Stack Overflow.

I’d never tried to use one to do a whole project with multiple discrete pieces.

Could I have, as that one person apparently tried, just said “make a thing called imgup. It needs to post pictures to flickr or smugmug from the command line, operate on the selected file in the Finder or Photos, and optionally post to Mastodon,” well, no, that would not have worked.

It didn’t even “work,” in my early first attempt to allow for its shortcomings, to make a thorough project prompt and keep sessions concise: It was incredibly inefficient, forgetful, and self-defeating, constantly introducing regressions as it forgot how one piece connected to the other, even when it had a copy of the repo attached to its project memory.

What finally made it “work,” if our definition of “work” is “make code that does what I want with about as many obvious bugs or issues as if I’d devoted months to this project starting from scratch,” was leveraging Basic Memory to give it some persistent project knowledge, careful marshaling of its limited session lengths, fastidious continuity prompting, and the occasional “go describe this problem to another instance outside the project to see if an evil twin can poke holes in the solutions offered by the other AI ‘developer.’”

So my curiosity is satisfied, for the most part.

Less public than this project, though, is all the writing I’m doing for myself right now not about how to make it work, but what to make of it – “AI” – generally. Because as surely as there’s a wide and varied distribution of takes on whether AI can do this or do that, if it’s “real” or “just smoke and mirrors,” the social issues are at our doorstep. This almost felt like me saying to myself, “well, you know what it can do; so now you can figure out what it means.”

Over the weekend I roughed in support for posting to gotosocial or Mastodon imgup, but made a decision about UI that my old jazz band director would have called “a choice that was not as good as the other ones,” and it took trying to wire the new functionality into a Raycast script to catch how it was a problem.

So this morning was “untangle that mess” and I think it’s in a way better place:

• Post to flickr or SmugMug and get back a Markdown, org-mode, or HTML snippet, same as before.
• Post to Mastodon or gotosocial with post text and visibility settings
• Optional tags, title, and caption (which we use as alt text for image tags and social posts)

I have a couple of Linux laptops, so the core tool is written for the command line to make it easily scriptable, but remain amenable to working in demi-GUI workflows, such as a Raycast shell script action or something like Shortcuts or Automator. Here’s a sample Raycast action to upload the selected image in Photos. You can even hook it up to a Hazel folder action that knows to pull the title and caption from metadata.

To add an image to this post, for instance, I:

• Found a photo in Apple Photos
• Triggered a Raycast script and added title, caption/alt, and tags
• Got back a Markdown snippet on my clipboard: ![Asphalt factory machine shack](https://farm66.staticflickr.com/65535/54550622732_10eb18d114_b.jpg)
• Pasted it into this post

The original impetus for all this was “blogging providers don’t care about image quality and it shows,” and that was why imgup started as a little Sinatra-backed web tool. The impulse that eventually took over was “reduce as much friction to uploading and sharing images as possible.”

For my own use, I’m trying to build surrounding tools that reward good behavior: The Hazel upload action, for instance, will grab existing metadata: That’s a great reason to include title and caption in my editing workflow in Lightroom. In the short term it makes posting simple and frictionless. In the future, I’ll be more grateful for the title and caption than the 30 seconds I saved by not posting “the long way.”

One semantic thing I need to back out of or address: Photo tools are all over the place on the metadata they expose and allow you to edit. At some point LR CC added an alt text field, but imgup’s “caption” flag acts as the alt text for the image tags it produces or the social media posts it makes. I need to look at the SmugMug and Flickr APIs and think about the logic there.

And I want to add Bluesky to the list of supported services.

The reason for the trawl was to get back to a practice I used to follow a long time ago where I’d wake up in the morning and load up Flickr’s “Explore” feed in Flipboard and make myself flip through it for a while. It was a little hard to do some mornings, but I stuck with it, adopting a mindset of:

• You don’t have to like all of it.
• There are better and worse choices, so figure out why you think which is which.
• You’re not as good as a lot of these people, but you do your thing for your own reasons, not Flickr’s (or anyone else).
• Figure out why things work or don’t work for you. Don’t do the things that don’t work, learn how to do the things that do work.

I think this is just basic self-development for people, I just had to learn it for myself because … well because.

So the trawl was to find accounts with a high percentage of media-only posts along with the absence of a list of stopwords in their posts, and the reason was to put them in a Mastodon list so I can wake up my Exposure Therapy approach, just using Mastodon instead of Flickr Explore. I just looked in on Explore, and it is about the same as it was. I think it could serve the same purpose, but I think the photography I see on Mastodon is a little more to my general taste, but not so much I’m closing myself off from learning opportunities.

Several years ago I read Cal Newport’s Digital Minimalism, going into the book thinking it would be one thing and learning it was something else I was much happier to think about, which was “why am I doing any of the things I do?” I spent a lot of time inventorying, thinking, and writing about that question, figuring out what my purpose was.

Some of that was painful to do. A few weeks ago Al asked me for some advice on a problem she was dealing with at work, and my opinions on the matter were so reflexive and so anchored on what is turning into a big portion of my life thinking about management problems that I felt a little dizzy and had to just stop and reflect on where that all even came from.

“I wish,” I said, “that I knew less about solving management problems than I seem to know. I could have been doing something else with all that bandwidth.”

So “what is my purpose? Why do I do these things?” were hard to ask because I had to spend a lot of time thinking about what the answers might have once been, and consider what I thought of being pulled away from that.

But from the exercise came some clear answers about what I do: I write, I take pictures, I read. Almost everything I screw around with, fiddle with, experiment with, or futz with has something to do with one of those things and some idea I have about how it will make one of those things better somehow. My reasons for doing those things are going to remain my own. I could share the ones that don’t feel super personal to me, but they’re the kinds of reasons you probably have yourself if you do any of those things much.

I’ve made a sort of mantra out of that list.

My rabbit holes are adjacent to my interests most of the time, but their utility is never completely guaranteed: Sometimes parts of my personality come to the fore that make my rabbit holes and digressions feel wasteful. They don’t pan out, or they do and they aren’t as useful as I hoped, or they triggered a bunch of fussing around with something that was fine as is. When I’m done, I feel a little dulled and uneasy, and I think “I could’ve been writing, or reading, or taking pictures.”

When I’m feeling very reflective I feel pretty self-conscious about those time-sucks. They feel like failures. I try not to be too hard on myself, because I’ve also come to realize there is probably something going on it’d be good to try to tease out. Like, I can tell you exactly why I haven’t been reading or writing much lately, and it has been helpful to know that and remember it.

So back to Claude: It has powered a sort of “oh, that’d be cool” digression factory that is always in sight of what I care about, but is always not doing the things I care about. It got really bad with one small project that spun out until I’d burned a whole evening on it. The time was just gone. And I wish I’d noticed for some reason besides “this didn’t pan out, why did I spend this time on it?”

So today I made the “focus guardian” prompt and stuck it in Claude’s user instructions. I think people tend to use that for facts about themselves, or the tone they prefer in responses, or whatever. I decided to use it to get a little help with my digressions. It’s a little lengthy, and I’m saying enough about the inside of my own head to even discuss this in public, so I’ll just outline what it does in the 350 words it takes:

• Looks for red flag expressions and requests
• Intervenes with a mix of questions and principles
• Suggests some alternatives

It caught me this afternoon, asked an intervening question, and provided some suggestions. I folded my laptop shut for a few minutes and wondered what I had been about to do, and decided I might as well enforce this new protocol I’m trying to implement in my own skull by writing about it.

I started the day working through the setup for a gotosocial server. It took a little fussing with the Synology, but it’s up and running. There’s a little more to it than “because I could,” but not much. I think I’ll find a few things to follow from there that are not humans with feelings and see how well it runs before moving there.

But that made me start thinking about imgup and how it’d be kind of cool to be able to use it to post to Fediverse services. So imgup 0.10.0 does that by adding a way to enroll it with gotosocial as an app then adding it as an option when posting to Flickr or Smugmug.

Nothing has changed about the way it has traditionally worked:

imgup -c "Some caption/the alt text" --tags some,tags -b flickr imgfile000.jpg

… but if you register it with gotosocial, you can add the --post and --fedi switches to compose the post text and make a post.

imgup -c "Some caption" --tags some,tags -b flickr imgfile000.jpg --fedi --post "the text of your post"

You can run the OAuth setup for that up with imgup setup fedi.

v0.11.0, which I have not full tested offers a simplifed flow to sign imgup to use your Mastodon instance, and adds the --mastodon switch, which behaves the same way.

So, it’s becoming a little bit of a Swiss Army Knife:

• Use it to upload photos to Flickr or SmugMug and get back a snippet you can paste into your blog
• Use it to post photos to those services and also make a Fediverse post out of them
• Use it to just post to the Fediverse

When you use Flickr or SmugMug alongside creating a post, you get to take advantage of their image resizing, which is nicer than a lot of blog hosting services: The images being shared are optimized without being turned into mush.

I’ve got a few ideas about extending it to support Bluesky and Pixelfed. Bluesky would behave a lot more like the Mastodon or gotosocial functionality. Pixelfed has a few other features around albums and stories worth considering. Adding those sort of turns it into an image cross-posting tool for services open enough to work with one.

I rolled the lmno ‘drafts’ stuff into lmno-blog-capture, which is sort of like org-capture for a monolithic lmno.lol blog file: Invoke it, get a little transient window with a pre-populated heading, do your thing, C-c C-c to save/exit.

With the drafts feature added, you can configure a drafts file (e.g. drafts-lmno.md), position the cursor inside a draft you’re working on in your main blog file, and teleport it to your drafts file. If you’re done with a draft, you can send it back over to the top of your lmno.lol file.

I added a bit of polish/a potential shoe-gun to the draft thing since I last wrote about it: When you shuttle something out of the drafts file, it overwrites the date stamp with the current date.

That’s me thinking more like a writer-who-publishes than a diarist-who-logs, and also keeps me from having to contemplate sorting the headings in the monolith.

The new #fujifilm #half looks sort of fun. I checked its dimensions against the XF10, and they’re quite similar.

I re-read some release reviews of the XF10, then looked it up in Lightroom. I didn’t take too many pictures with it: I’ve never really done well with cameras that don’t have a viewfinder, and I got mine during the summer, when working with an LCD on bright beaches, etc. was a challenge.

But still: APS-C sensor in a genuinely pocketable camera, similar to a GRIII, and it had a snap focus setup I didn’t appreciate at the time but got better at when I did get a GRIII, which has a similar feature.

I think, at the time, I was perturbed that it didn’t have Acros, and I was still all in on the notion that X-Trans sensors were dipped in unicorn juices before getting seated in the camera. Still, I never got rid of it, so I dug it out yesterday and charged the battery. I think the trick with it might be to re-learn the snap focus feature and dial in a decent film simulation preset.

I also don’t see a half in my future too soon. I own one of the digital Instax hybrids. It’s far too bulky to just carry around, and the … hybridity? … of the thing feels grubby: They don’t let you use the camera to its fullest without forcing a film purchase on you. The half isn’t that bad about it, but the most thorough review I’ve found suggests they’ve committed to the bit a little too hard for the money. What I’d like would be an XF10 successor with an optional OVF or EVF and a little more wherewithal. Or maybe not. I eventually sold the GRIII because it wasn’t so pocketable that it made a ton more sense than an X100.

Anyhow … the XF10 is sitting there. Seems like fun to mess around with it.

Oh, the comments in the Petapixel review are tragicomic. The worst part of photography sites is truly all the photographers.

A long while back I had a small falling out with a boss. I was a green manager and we were trying to figure out what I needed for headcount. I had no idea how to have that conversation: I just knew “more people == more work done.” After a few back-and-forths, he finally realized I wasn’t getting it, and he said, “Look, I need to know each thing the team is doing, how important you think it is, and what it takes to keep the lights on. Tell me that and we can figure out if there’s something we could be doing differently, or slow down on, or reprioritize.”

Oh.

At the time I was full steam ahead on a Rails app that helped manage technical docs. We’d grown the page count 3x in just over a year, and we were starting to miss things like product screenshots that didn’t change. We also had problems with internal customers telling us they weren’t sure how to tell us about issues. So the Docs Decomposer offered up a rendered view of all our Markdown docs. You could leave a Google Docs-style comment on a selection, and you could also use a bookmarklet with it that let you select a problematic passage and file a Jira ticket with it. It also tracked screenshots and reported on which ones hadn’t changed between versions so we could look in and make sure the product hadn’t changed too much.

Since it was already up and running on internal infra, I just went home and started modeling how my boss had told me how to think about prioritization, and I made a tool that sat in an unlinked page in the Decomposer. You could enter a list of the stuff your team did, then tell it the priority of the item, how well you thought you were doing it, and how much effort it took. If you said something was a P1, but you weren’t doing it well, you got a little “this is on fire” treatment on the priorities report.

So at our next 1:1 I put my browser on the screen in the conference room and walked my boss through what we were up to. We had a great conversation. He thought some stuff we were doing was better left to developers to work on, and he had some stuff he wanted me to emphasize more, and he agreed two more writers for the coming year would be a great idea.

I ended up turning it into an app of its own, adding accounts and separate projects. I developed a practice around it with my teams:

1. Dump what you’re doing into the tool.
2. Set Priority, Support, and Effort.
3. Look for disconnects.
4. Renegotiate priorities.

I kept it pretty simple. Each priority has a page that shows similarly prioritized or supported items to give you an idea of what you’re ranking similarly, and there’s a notes field to capture whatever.

It works well with some teams, not so well with others. I’ve learned over the years that you have to help the team keep from spiraling into minutiae, and you need to keep an eye on guilt reactions. But when it works, it’s very clarifying and you can cut a lot of junk out of the backlog.

It’s such a simple idea that it didn’t really need a Rails app. One manager I hired just made his own version in a spreadsheet. Another did Jira reporting with labels. The value isn’t so much the app as it is the thinking process, and having a supportive, thoughtful conversation with your team about what they’re up to, what you can take off their plate, and where their time could be better spent.

Tonight it took about 30 minutes with Claude to get it turned into a PWA that does about the same thing. It uses local storage and you can save it to your phone’s homescreen. I don’t think the app interface is good for a tool like this. It’s meant to be a “put it on the screen and let everyone talk about it,” but I wanted to see how simple it would be to talk through the design and turn Claude loose on it. It took about 30 minutes of back-and-forth. Enough to get it working and convince me it’s not a great idea for phones, but could be a simple webapp that doesn’t need any infra.

People have asked me if I could dig out their logins to it years after we’d worked together, so it works for some kinds of brains. And I’ve thought a lot more about how prioritization works (or doesn’t) since I built it. I like the idea of treating it less like AN APP YOU USE and almost more like an educational tool for people who are new to thinking about prioritization and don’t really have their own model yet.

For instance, just looking at the little report, it could do more to suggest overall backlog health, and it could offer ways to think about disconnects. One thing I never got around to coding in last time but was able to add in two minutes tonight was what to do when something is low priority and getting a lot of effort. It used to be those items got a green checkmark … now they get called out.

Anyhow, fun.

I managed to get too many plates spinning again, and made it worse for myself by trying very hard to use Asana, because it’s what we use for a few things at work and it’s easier to send todos back and forth in 1:1 and team boards. My own personal project board isn’t great and I vacillate between a column view and list view, but the fact is Asana just makes my brain freeze. I do not like it. It doesn’t matter how I arrange the view.

I think it is extra infuriating to me because I recently tried to add a project status field and noticed that easily ten of my coworkers had each created their own custom “red/yellow/green” status fields and added them to the collective library. They’re all just red/yellow/green. Not other metadata, no nothing. You can’t have not seen the other nine in the library in the process of deciding to make your own, but here we are. People are animals.

But too many plates, and I was feeling miserable and behind, so I opened up a fresh org-mode buffer and started outlining it all instead of trying to make it into little tasks or cards or whatever.

I keep coming back to something I love about org-mode: You can dip in and out of planning and writing about what you’re planning so easily: One second you’re defining a TODO, the next line down you’re writing about it. No dipping into a notes box, etc. If a paragraph into the whole thing you think of a few extraneous tasks, make them checkboxes, keep writing, and add a cookie to the parent when you think of it so you can see completion. Decide a thing needs to get parked … org-refile it to the * Parked heading and keep moving. Setting priority is just S-up or S-down.

The only thing I regret is having to re-learn this over and over. There is a little extra overhead to keep an org project file and also do the necessary ticketing in Asana to keep things going with the team, but I can’t think in Asana, I can just track there. Different things.

I took my corpus of old micro.blog posts and migrated them into my notes. They’re all YAML-n-Markdown, so they could just be imported.

I did the same with my mono-topic Hugo posts. Same idea.

I made a script for the many, many daily posts I wrote over a few years, grateful that I stuck to a convention of organizing them with l2 headings: Each heading became a title of a new, atomized post. I did that because my daily posts could cover a lot, so now it’s all more searchable.

And I finally sat down with my DayOne journals, all exported as JSON, and turned them into Basic-Memory-ready Markdown (which is to say “Markdown”). That included not just my journals from as long as I’ve been using DayOne, but also the entire collection of 2,000 posts from my original blog – the one that started as MovableType, then became WordPress.

Oh, I also imported my Scribbles blog.

I’ll put the source material up somewhere safe, but for the first time I have about 25 years worth of journals, diary entries, blog posts, and other personal writing sitting in a repo in a mostly standard format, organized by source.

It all also caused me to look at a 15-year-old project I worked on when management came around and told my team we’d have to spend three weeks classifying 17 years worth of articles from 40 sites in a spreadsheet. I mustered my rudimentary Ruby and wrote autotaxonomizer in an afternoon, got a friendly dba to give me an article dump, sold my boss with a proof of concept, and reduced a three-week slog for 12 editors to each of them spending maybe 30 minutes filling out a spreadsheet with the keywords for their site categories.

Maybe the best part was after I talked the rest of the team through what I was going to do and noticed a text from my best work friend, Amy. I thought it was gonna be “awesome!” but it was “This sucks. I was looking forward to three weeks of just filling out a spreadsheet.”

I’m back on Doom after patiently dismantling a bunch of cruft I’d added to it. I set a goal of getting my package count under 200 (including all the batteries Doom includes). Because its default stance is that you want emacs-lsp and not eglot I went along with that initially, and it drove me a little bonkers. I think these things assume a much more organized person than I am, and LSP began to nag pretty much constantly until I made the mistake of telling it to blocklist ~/, at which point it pretty much stopped working, because there’s an implicit -r in there.

So I toggled eglot in init.el, and the nagging stopped. It seems to need less explicit guidance.

Something I like about eglot as it works in Doom vs. emacs-lsp is that if it doesn’t have a needed server for a given mode, it just tells you that in the minibuffer. It doesn’t steal focus, demand action, or try to download anything for you. emacs-lsp (at least as Doom handles it) does all of that stuff and it’s disruptive. I think it’s an attempt to help you keep flow by just handling the matter, but about 1 time in 10 in the past it causes a hang and that sucks way worse than “first time editing this code, pause, install, resume.”

That brought me to “now that it is not driving me to distraction, why do we even want LSPs?”

With Markdown it’s to have Marksman, which does this very cool thing where if you lead with [[ it offers autocompletions of all the Markdown files in your project and creates a wiki link to the file you can then hop over to with C-c C-o or just by tapping return if you toggle wiki links in markdown-mode.

With everything else, it’s just sort of educational to have something smarter about the code than me providing running commentary.

Next up, I had turned on Doom’s support for code formatting/prettification, and that was causing everything to barf errors on save, most because I hadn’t installed an expected formatter. Doom uses apheleia, which is pretty well behaved but was not working with Ruby. That got annoying because you have to grab the formatter (prettier), then deal with some errors that’d seem to have nothing to do at all with the fact that it wants a .prettierrc either in project root or ~/.

I knew I got it working because I ran it on this:

#!/bin/env ruby

fruits = ["apple","banana","orange"]

fruits.each do |f|
  puts f
end

apples = ["golden delicious", "honeycrisp", "fuji"]

apples.each do |a|
  puts a
end

… and got back:

#!/bin/env ruby

fruits = %w[apple banana orange]

fruits.each { |f| puts f }

apples = ["golden delicious", "honeycrisp", "fuji"]

apples.each { |a| puts a }

I sat with my feelings about that for a few seconds and decided it was educational. It’s never really been about being particularly good or sound or correct, just about getting the thing to run.

(defvar mph/blog-drafts-file (expand-file-name "drafts_lmno.md" "~/journal/blog/"))
(defvar mph/blog-published-file (expand-file-name "lmno.md" "~/journal/blog/"))

(defun mph/move-heading-between-draft-and-published ()
 "Move current Markdown L1 heading to the other blog file (drafts_lmno.md or lmno.md).
If in drafts_lmno.md, moves to lmno.md. If in lmno.md, moves to drafts_lmno.md.
Always inserts at the beginning of the file."
  (interactive)
  (let* ((current-file (buffer-file-name))
         (target-file (cond
                       ((string= (file-truename current-file) (file-truename mph/blog-drafts-file)) mph/blog-published-file)
                       ((string= (file-truename current-file) (file-truename mph/blog-published-file)) mph/blog-drafts-file)
                       (t (user-error "This file is not drafts_lmno.md or lmno.md")))))
    ;; Save and cut the heading
    (save-excursion
      ;; Find the beginning of the current L1 heading
      (beginning-of-line)
      (while (and (not (looking-at "^# ")) (not (bobp)))
        (forward-line -1))
      (unless (looking-at "^# ")
        (user-error "Not on a Markdown L1 heading"))
      (let ((start (point)))
        ;; Find the end of the current heading (next L1 heading or end of buffer)
        (forward-line 1)
        (while (and (not (looking-at "^# ")) (not (eobp)))
          (forward-line 1))
        ;; Cut the heading and its content
        (let ((heading-text (buffer-substring-no-properties start (point))))
          (delete-region start (point))
          ;; Paste into target file at beginning
          (with-current-buffer (find-file-noselect target-file)
            (goto-char (point-min))
            (insert heading-text)
            (save-buffer)))))
    (message "Moved heading to %s" (file-name-nondirectory target-file))))
;; Doom leader key setup
(map! :leader
      :desc "Blog commands"
      "l" '(:ignore t :which-key "blog")
      :desc "Move heading to other blog file"
      "l r" #'mph/move-heading-between-draft-and-published
      :desc "New lmno blog entry (md)"
      "l b" #'lmno-capture-post)

Just, SPC l r on a given l1 heading to shuttle it to either the drafts file or the main blog file.

I started the day playing around with MCP’s for Claude Desktop. I found one for Emacs and one called Basic Memory.

emacs-mcp-server sends evals to your running Emacs instance via emacsclient. It’s sort of fascinating to watch in progress. Not the fastest thing on the planet, but it was a jolt the first time I turned my attention to something else and came back to realize it had created a new function and added it to my configuration.

It was an even bigger jolt when I went after the problem of Emacs not being properly associated with a number of file types on my Mac:

It wrote a script to use duti to make all the associations, and when I reported that they weren’t “sticking” it decided to write a systemd agent to periodically re-run its duti script. I didn’t realize that had happened until macOS sent me a notification that something new was running on my behalf.

I … am not sure what to make of this, entirely.

Well … a little I am.

For about an hour, this seemed very cool. I haven’t used Claude much, but with it able to pilot Emacs we got through a small reimplementation of org-capture for Markdown files that built on a few recent projects and allows for simple templating. Neat. Pretty complex. Functioned correctly.

Unlike previous sessions with an LLM doing this kind of thing, though, it was a little dulling and weird to have Claude and Emacs quietly collaborating to write all this. It got me to a fundamental understanding of how I am feeling about LLM-driven development:

I have one eye cocked over my shoulder because most people I know personally do not like to admit they perceive any utility with these things, often seem uncomfortable mentioning it if they do use them, and seem to feel a small, almost ritualized compulsion to shit on them even if they do perceive utility. There are any number of reasons someone might be there with these things. They activate a whole catalog of anxieties and irritations.

But I am able to make things with these tools I couldn’t make without 10x the time and effort, and the things I make let me get to what I want to do and spend less time doing the toil of supporting activities more quickly.

I guess I think that they are labor saving devices with the same caveats riding lawnmowers are. Like, I’m glad to be free of the scythe, but also once I have a new John Deer riding mower I understand I can’t sort of tie the steering wheel to a 15 degree angle, put a brick on the accelerator, and get back to my nap.

And I understand they’re not people replacing. Even with the modest projects I work on I can see that.

But one thing I’ve come to enjoy is the part that involves playing to their weaknesses:

I can’t sit back and say “make this thing for me that does some broad directive.”

I have to ask for something simple, then slowly layer things on, redirecting from blind alleys or unwanted optimizations. It’s a creative, iterative process and I enjoy it. It’s a way to engage with a problem I’d like to solve that involves patiently working through the steps of the problem, having second thoughts, realizing that I want things that are at odds with each other, sometimes realizing there’s a much more elegant way to do something. The things I end up with are maybe not the best in terms of their coding craft, but they’re tailored to my mental model.

So Claude and Emacs working in concert removed a small amount of friction I actually welcome in the process of looking at code, moving it over, reading it before evaluating it in a buffer, etc. I didn’t care for that. It was alienating.

The other MCP server I mentioned, Basic Memory, sits in Claude Desktop and remembers what you tell it by writing Markdown notes in a directory. They’re basic “Markdown-n-YAML” files with light structure. You can have the usual sort of “talk to a robot” conversation for a while, then prompt it to make a note, and it does. Then those notes become part of its persistent context. There are db-backed services to do this at scale, but it suits me very much to have something like this. It’s super transparent and introspectable.

In addition to notes, you can record “Observations” in your Markdown files. Observations are simple lines of Markdown, as these examples from the project repo:

- [method] Pour over extracts more floral notes than French press
- [tip] Grind size should be medium-fine for pour over #brewing
- [preference] Ethiopian beans have bright, fruity flavors (especially from Yirgacheffe)
- [fact] Lighter roasts generally contain more caffeine than dark roasts
- [experiment] Tried 1:15 coffee-to-water ratio with good results
- [resource] James Hoffman's V60 technique on YouTube is excellent
- [question] Does water temperature affect extraction of different compounds differently?
- [note] My favorite local shop uses a 30-second bloom time

These become grist for the MCP, alongside your notes, creating a sort of synthesizing glue, and it persists from session to session.

It is still far too early to say much about this. I’ve got a few ideas about how to use it in some work and personal contexts, but haven’t paused long enough to think of a workflow to facilitate those ideas.

( Note: Updated this post to narrow down a little more finely the kinds of social responses to LLMs and their use I have noticed.)

Over on the other blog I recently enthused about SyncTrain, an iOS SyncThing client. I still maintain it is very good, but wow did I end up foot-gunning with it:

I set Journelly up to use a SyncTrain share on my iPhone, promising myself I’d make sure to do the occasional manual sync, never leave my Journelly file open when not editing it on one of the real computers, etc. I still managed to end up with a sync error, and SyncThing dutifully created a sync error file. The Journelly app picked up that file and started using it as the default file to write to – I’m assuming iOS filesystem arcana is involved – which I wouldn’t have noticed if I hadn’t manually peeked in the directory instead of just using an org-capture template to make Journelly entries on my Mac.

This was only going on for two days and three short entries, but it was pesky: I had a Journelly.org file that went up to Sunday, then a Journelly.sync-error.org file that had grabbed those three short entries, and also spawned a Journelly media folder with the same name. The fix, in the end, was to move my Journelly.org file and media folder into an empty iCloud folder, delete the Journelly app, then reinstall it and immediately tell it to use the new iCloud location. Then I was able to go in and tack on the three entries from the conflicted version. So no data lost, but in hindsight it was a bad move to try to use SyncThing on iOS for app data: There is no reliable background syncing on iOS, just semi-manual workarounds, so it’s inevitable that there’ll be a conflict.

The recommended non-in-app storage method for Journelly is iCloud, and I’d endorse that if being able to edit your Journelly file on the desktop is mandatory.

It’s not a ding on Journelly. It can only work with the files it tells you to. It’s not a ding on SyncThing, which I use for several other applications. It’s not a ding on SyncTrain, which does the best it can with the limitations iOS imposes. And it’s not a ding on iOS, which we all understand quite well at this point: It doesn’t really tolerate long-lived background services and nobody has ever pretended otherwise. It’s on me for thinking it was a good idea in the first place.

Rainy afternoon here on the last day of the work offsite. We all went down to Pine St. Market and had ramen at the end of the day, and I said goodbye to some of the folks who came in from out of town. A few I’ll see once more for dinner tomorrow.

This kind of work function is always a little draining by the time it’s over. Spending days in a small room, even with pretty good people, just takes some battery, and this one was a little melancholy because one of my teammates is moving on.

I’ve been so happy with my emacs-plus install that there was an when-not-if element to the whole thing. It came today when I tried to get org-capture to work and it … just wouldn’t. So I tried an alternate build and lost over an hour I could have spent writing to uninstalling, reinstalling, troubleshooting, rewriting a launchd agent, etc.

I’m sensitive about my writing time, because my first team is in town this week and I’ll be spending most of my days and a chunk of my evenings downtown doing strategy stuff with some great people, but I won’t have any writing time. So that time I could have had today is lost.

… and I guess I’m annoyed because it was such a stupid little rabbit hole: I thought something sounded sorta cool, figured it’d just take a second and then poof. And such a violent poof that stuff I’d had working just fine an hour earlier suddenly wasn’t working thanks to some mystery of I don’t even know what.

So, back on track again. In the end I just had to clean up some of my config’s hygiene, and that was probably for the best anyhow.

But still down over an hour of writing time.

Spending this much time writing about it probably seems like a bad reaction to a small thing, but part of what I have liked a lot about my increased journaling and personal writing output has been the opportunity it affords me to learn and internalize. So this is sort of a public exercise in re-learning something: I’m happier when I’m making a thing, not when I’m fucking around with the tools to make things.

I abhor feeling attachment to things.

Years ago I was out in the garage going through some old boxes at the same time I was thinking about some people I knew who seemed very connected to what they had been, and uncertain of how to go about being who they had become. So when I reached into the box and pulled out some old object I thought, “I don’t want this thing anymore,” then I thought “oh, but it’s a reminder of …” and then I thought, “I’m in no danger of forgetting that time.”

Since then, I’ve tried to just … put things aside when it occurs to me.

My collection of digital photographs is not something I feel able to simply set aside. I got a reminder of that this afternoon, when I noticed Arq complaining about a failed Lightroom backup that, on initial investigation, appeared to be a tanked drive. The drive had not tanked, but there was a moment of uncertainty about whether data was lost, and how much that might be, what it would take to recover it, etc.

I’ve got my Lightroom stuff split into two vaults. One runs from ca. 2000 to 2014, and the other covers 2015 to now. The vault with older stuff just sits there. It’s poorly curated, with duplicates and culls all mixed in. I am sure most of what I care about at all is in the equally desultory shoebox that is my iCloud Photos collection. It’s all backed up both to NAS and my B2 account (though, you know, B2 seems less ikely to outlive me than I’d hoped) but it’s not usable to anyone in my family, really. It’s just a mess that happens to be backed up. The newer vault is in a little better shape, but it’s still not great.

Anyhow, the brief not-incident reminded me of the project I’ve meant to for a couple of years:

• Go through year by year and figure out the 50 or 100 images from each year that get five stars. I’ve done that for a few years, but when I went way back it got hard.
• Opportunistically delete the culls and duplicates when I spot them.
• Make an artifact out of the five-star images. Right now I’m thinking photo books.
• Organize those “best of the year” images somewhere they’re easy for family to find. flickr has an actual non-profit foundation now, and it’s not expensive to maintain a Pro account.
• Establish 3-2-1 backups terminating in Glacier, and quit thinking about it all as a potential thing. Rather, realize the potential as best I can imagine living with, and then set it aside.

There are a few other moving parts I identified as I was outlining how to set the project up and actually do it, but it’s definitely time.

I am not sure how this will go and it could be this is futzing under another guise, but this evening I did improve on my futz pattern a little by choosing to devote a journal entry to some thinking I’ve been doing about The News, how to consume it, how much to consume, etc. etc. IOW, instead of diddling around with a tool or a toy, I started writing about something that matters to me.

Ordinarily, writing like that either gets punted into a blog post pretty quickly or gets a few sentences then peters off. Worse, it sometimes becomes a blog draft that I kill because it’s not a viable blog post for whatever reason, but now it’s too other-oriented to be a good journal entry any longer.

Tonight I started drifting in that direction – the blog post that would not come to a good end– and I didn’t like that. But there’s more to think about because when I look at my behavior toward news media in the past several months something has definitely changed very profoundly, and while we can all guess why I’m not sure how to feel about that yet.

Last time around, post-2016, I picked up a lot of baggage about media consumption, what I made of other peoples’ apparent patterns, what I thought that was doing to them, where I thought it was coming from, and what I thought of all the rationales people deploy to justify their choices.

This time around, I can feel some of those thoughts rolling around inside, but I feel a little more detached from them, it feels a little less personal, things that seemed very urgent seem less so, and some stuff just can’t be allowed to matter. It turns out someone is still wrong on the internet.

But I don’t want to write an essay about all of it. I’ve never liked outlines much. So I decided to experiment with atomic notes on this topic, just committing little nuggets and chaining them off of each other, but when I could tell I was headed out of the narrow confines of one atom – say, “what’s good about the news?” – and into another atom – “how much news is enough to get the good parts?” – I made a new atom and picked up there.

It helped me in one way that didn’t occur to me going in, which is that it’s much easier to resist having a narrative of some kind, or an urge toward a conclusion. When I asked “what’s good about the news?” and wrote about that, and then thought, “probably a good idea to make a sibling to ask what’s bad about it,” that got its own node and I didn’t have both sets of things sitting there right next to each other jostling for head of the line, or demanding I steer toward the conclusion.

Because I don’t have a conclusion. All I know is that something has definitely changed in my thinking and behavior around a core part of most college-educated peoples’ ideas about how they’re supposed to behave in the world, and I’d like to think it through without having a conclusion in mind. So we’ll keep at this for now.

Oh, right, what’s the toy: Denote and denote-sequence. Of all the note frameworks, etc. that I’ve played around with, my org-based Denote notes are still the most legible, useful, and navigable. Still getting the hang of how to wrangle a sequence, but not so much that I’ve had to stop writing and screw around with it to the point of a derail.

In the process of getting imgup to broaden its horizons and work with flickr, I remembered that I actually like flickr (which is owned and operated by SmugMug now). It’s just more oriented around “you want to put photos up online,” without any emphasis on being a “pro,” and without Glass’s … whatever it is about Glass’s vibe.

In the end, it’s not about flickr being a permanent “home.” I wouldn’t trust any commercial entity to be home for my photos. But it’s a fine place to put photos to share.

Yeesh. So, re: imgup. It is pretty much “done” to me as a tool. Meaning, it does exactly what I want it to do, plus a few things I didn’t start out with. There’s maybe one more tweak (“just give me the URL”) I can go add in five minutes when I get around to it. But today I was thinking “oh, it’d be cool if it had a history,” and “oh, it’d be cool if it could show thumbnails in kitty.”

No real utility to those things, exactly. Well, the history idea kind of has utility. The kitty thumbnails thing is sheer “what if I could …” pointlessness I’d never take advantage of. I was just riding in the car up I5 from Eugene, sort of daydreaming, and I imagined what the feature would look like and got a little curious.

But making it do that would just be noodling I could do to noodle. It’s not doing the things I made that tool to help me do, which are write and share photos.

I’m glad I realized I didn’t need to do anything more with it. I guess I just wish I didn’t have the impulse to begin with. I’m sitting around the house, maybe a little bored, not wanting to do anything in particular … I’d rather my first impulse be “pick up a book,” or “work with some photos,” or “listen carefully to some album.”

I think some of this is recent back problems. I let myself stop running for a few weeks and tightened up, so now it’s a back-and-forth process to get the stiffness worked out, and it feels great to spend a lot of time in a chair with a heating pad, being acutely aware that I don’t want to do much. But “not doing much” has seeped into things I could be doing, not just things it’s probably not a good idea to do a ton of.

For whatever reason I have an allergic reaction to the phrase “distraction-free,” but as I’ve waffled back and forth between org-mode and Markdown as the starting point for prose I’ve also thought about how my model writing app on macOS is probably iA Writer, because it’s just so easy on the eyes. I kinda buy the limited choice it offers, too. That might be why it edges out Ulysses.

So I’ve given writeroom-mode for Emacs a spin and it does a nice job of presenting a simple, clean writing screen. No modeline, pulls the margins in, and you can enlarge the font (and pick a variable pitch one).

On a macBook with Emacs running in full screen mode it is, indeed, pretty distraction free. Using the monokai-pro theme, it’s plenty contrasty, but not glaring.

It’s sort of nice having a good Emacs build again. When I have an overloaded config with too much going on, things feel sort of rickety and weird and there’s an underlying sense of non-calm under the surface that makes it hard to use as a creative tool.

When it’s set up for simplicity and stability – when there’s less junk going on – it’s able to just sort of look nice and feel comfortable.

Does anyone else remember Mixel? It was a collaborative collage app that arrived early in the iPad era, was amazing for a little while, then pivoted into online postcards or something, then slipped under the waves.

You started with a blank canvas and a collection of images that sort of acted like stickers you could plop on the canvas and manipulate into a collage. The collection was socially driven, so for periods something would find its way into collective consciousness, spawning a bunch of riffs on a theme.

You could import someone else’s Mixel and get access to all the little clips and elements they created.

There were some genuinely gifted people on Mixel, making little collages out of tiny, intricate parts. There were a lot of goofballs. For periods someone would drift through your field of view, and maybe you’d start playfully volleying ideas back and forth, then one or the other would drift off.

Possibly one of the best creative-apps-with-social-component ever.

All the ones I managed to preserve before the service tanked.

So for a long while there, almost every night, it was just “grab a camera and go somewhere.”

I guess I’m thinking about it because when we were walking on Foster Road last night I noticed that three places that had kept their outdoor areas all the way through now have taken them down in the space of a week.

flickr’s API is way more comprehensible than SmugMug’s, so adding flickr support went down much more quickly. Just get an API key/secret (links in the README) and step through onboard to auth your copy of imgup.

Otherwise, it’s the exact same interface and UI. You just have to add a --backend argument to use flickr when you run it:

imgup -b flickr -t "The Title" -c "The Caption" -f md img_123.jpg

You can skip any of them except the image itself, but you probably want to set --caption to get a description/alt text back.

pdxmph/imgup-cli (Gem on the release page)

I also added a pair of extras:

• A Hazel folder action script: If you set the “caption” field in LightRoom or Apple Photos, then export an image into the watched folder, you’ll get a snippet back to your clipboard with the caption as description/alt text.
• A Raycast script action: (Needs to be fixed to use the new backend selector, so hardcode that if you want to just get it running with flickr by adding the argument in the script)

I’ve been using imgup as a cli tool for a few days and it has worked pretty well. A few things bothered me about it:

• The OAuth situation was janky and not very portable. You had to have a .env file with very little help in the way of configuring it.
• Onboarding via oauth was non-existent.
• Configuring a target album involved fiddling around in the API or knowing exactly where to hover your mouse on the website.

So I spent some time just cleaving the CLI out of the core project and working on cleaning some of that up.

There’s a new repo, and a better onboarding deal:

• Install the gem (available from the release page)
• Run imgup setup
• Go through a not-great but viable oauth setup
• Reply to a prompt to pick a target album
• Get your config file written for you in a normal place
• Start using

No more .env files or any of that. It behaves way more like a normal app you can just go install.

I wanted to get it into that shape because I like how it is working now: It’s a little bit of plumbing you can fit into all sorts of possible workflows to make it easier to do a small thing that can involve fiddling and typos when all you really want to do is put an image in a blog post. At the same time, while SmugMug is cool and all, I’d like to fold in support for flickr, imgur, and maybe a few others that are more common, and also leave the web UI behind.

So as I have time and feel like messing around, I’ll probably go after flickr next, since I have an account and plenty of albums to play around with.

(I was hoping to include omg.lol’s some.pics, but there’s no API to talk to.)

I forgot I had one along on my trip to the Mutoid Man show and that was a mild bummer: The light was so low that the X100VI’s perfectly serviceable 3200 ISO had more of an uphill battle. On the other end of the spectrum, during bright daylight, they turn the highlights into a glowing mess.

I’m on the fence because I like the effect, but don’t like remembering/forgetting that the filter is on there at all.

• Write your blog in a monolithic org-mode file (set in Customize).
• Export it with lmno-org-export-blog .
• It opens the target file (set in Customize).
• If you’re a Mac person, drag the proxy icon into the lmno.lol uploader.

Here’s the org-capture template, which reuses the source file variable:

(add-to-list 'org-capture-templates
  '("l"
    "LMNO blog post"
    entry
    (file lmno-org-input-file)
    "* [%<%Y-%m-%d>] %?\n\n"
    :prepend t))

Under the hood, it has to do some footwork: org-export wants to wrap anything that looks like an org-mode date stamp with spans, and there is no configurable option for that. Likewise, it applies anchor id’s to every heading.

I am not sure what was going on with image attributes in all that, either, but they weren’t surviving the export with alt tags in place, so I found this custom link format in a Stack Overflow answer that somehow sidestepped the issue:

(org-add-link-type
 "img" nil
 (lambda (path desc backend)
   (when (org-export-derived-backend-p backend 'md)
     (format "![%s](%s)" desc path))))

1. Visit a flickr image in Safari or Chrome
2. Invoke the action from Raycast and:
   • select a snippet format
   • type in some alt text
3. Get a snippet in Markdown, org, or HTML with your alt text, suitable for pasting into a blog post

Why you want to do this:

1. If you’re all in on Flickr, then your blog becomes more easily portable if you ever move it, because the image tags have a stable URL
2. Flickr cares more about the quality of the embeds than a lot of blogging providers.
3. You’re using lmno or some other service that doesn’t manage image uploads at all, and you have to have a third party host.

Pick your poison: If you’re a forward-thinking SSG kinda person who has made it easy to ensure image tag hygiene in the event of a domain or platform change, this might not be appealing. If you’ve been doing this for 25 or 30 years and occasionally stray into the less portable corners of the web, but are willing to hitch your wagon to flickr, this is an option that compares favorably to “all your images were ingested, compressed into a mealy, blurry mess, and given an indecipherable path to some S3 bucket.” If you’re constantly playing around and moving posts back and forth between providers and frameworks, this could also be a helpful strategy.

#!/usr/bin/env bash
# Required parameters:
# @raycast.schemaVersion 1
# @raycast.title  Flickr snippet from active tab
# @raycast.mode silent
# @raycast.icon 🌄
# @raycast.description  Grab the URL of your frontmost browser tab (Flickr only) and copy a Markdown/Org/HTML <img> snippet
# @raycast.argument1 { "type": "dropdown", "placeholder": "Format", "optional": false, "data": [ { "title": "Markdown", "value": "md" }, { "title": "Org‑mode", "value": "org" }, { "title": "HTML", "value": "html" } ] }
# @raycast.argument2 { "type": "text", "placeholder": "Alt text (optional)", "optional": true }

set -euo pipefail

FORMAT=$1
ALT_TEXT=${2:-""}

# 1) Get frontmost browser’s URL
APP=$(osascript -e 'tell application "System Events" to name of first application process whose frontmost is true')
case "$APP" in
Safari)
    URL=$(osascript -e 'tell application "Safari" to return URL of front document') # :contentReference[oaicite:0]{index=0}
    ;;
"Google Chrome" | "Brave Browser" | "Microsoft Edge")
    URL=$(osascript -e 'tell application "Google Chrome" to return URL of active tab of first window') # :contentReference[oaicite:1]{index=1}
    ;;
*)
    echo "⚠️ Unsupported app: $APP"
    exit 1
    ;;
esac

# 2) Validate it’s a Flickr photo page
if [[ ! $URL =~ https?://(www\.)?flickr\.com/photos/ ]]; then
    echo "⚠️ Not a Flickr photo URL: $URL"
    exit 1
fi

# 3) oEmbed → JSON
ENC=$(python3 -c 'import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1], safe=""))' "$URL")
OEMBED=$(curl -s "https://www.flickr.com/services/oembed?format=json&url=$ENC")

# 4) Extract direct image URL
IMG_URL=$(echo "$OEMBED" | /usr/bin/jq -r .url)
if [[ -z $IMG_URL || $IMG_URL == "null" ]]; then
    echo "⚠️ Failed to extract image URL."
    exit 1
fi

# 5) Build snippet
case $FORMAT in
md)
    [[ -n $ALT_TEXT ]] && SNIP="![${ALT_TEXT//\"/\\\"}]($IMG_URL)" || SNIP="![]($IMG_URL)"
    ;;
org)
    [[ -n $ALT_TEXT ]] && SNIP="[[${IMG_URL}][${ALT_TEXT//\]/\\]}]]" || SNIP="[[${IMG_URL}]]"
    ;;
html)
    [[ -n $ALT_TEXT ]] && SNIP="<img src=\"$IMG_URL\" alt=\"${ALT_TEXT//\"/\\\"}\">" || SNIP="<img src=\"$IMG_URL\">"
    ;;
esac

# 6) Copy & notify
printf '%s' "$SNIP" | pbcopy
terminal-notifier -title "Flickr snippet" -message "Copied $FORMAT snippet" -sound default

The fundamental mania at work here is basically “wring all the motion out of a thing you can.” I wrote imgup because I hated what Microblog was doing to my photos, but also hated the whole shuffle of “upload an image to SmugMug, hand-write the markup to embed it in a post.”

So it was an incremental improvement to build a web UI that stripped all the extraneous motion out of that workflow using the only thing I knew very well, which is Ruby/Sinatra.

My recent journey into better note management reminded me it’s not terrible to work in a shell scripting environment, so that’s why I dusted off imgup, which was nothing but a web front-end until this week, and bolted on a CLI interface. I started that thinking “well, you usually just export photos from Lightroom or Photos onto ~/Desktop before uploading them with imgup, so just save a trip to the browser.”

Then that became “why even open a shell when you have Raycast there and understand how to work on selections in Photos or Finder with AppleScript?”

And then I remembered that an early pass at imgup extracted the exif caption to provide the alt text (since then Adobe has exposted a literal alt text field in Lightroom) because I was thinking “why not just embed that in the photo itself once, when you’re already processing it?” I don’t know why I abandoned that, but this evening my thinking took me toward “why even work on a file in the Finder from Raycast when you could just export the image straight from Lightroom to Smugmug via this shell tool you’ve built?”

So I wired imgup’s CLI to a Hazel folder action:

• Edit the photo in Lightroom
• Make sure to edit the caption field (this is the only thing Photos and Lightroom expose in common)
• Export to a Hazel-watched folder
• Set up a folder action that grabs the photo, extracts the caption, and feeds that as an argument to imgup
• Copy the resulting SmugMug link/markup/etc. to the clipboard
• Hazel dumps the copy in the trash

Barring Adobe doing something freakishly helpful, like adding a scripting library, I can’t think of any way to wring any more motion out of this thing: Type in a caption, press cmd-e to do the last export action, and the photo goes from Lightroom up to SmugMug and back to a snippet in my clipboard.

There’s one small tragedy in this, which is that Apple Photos both tells you that you are setting the “Caption” for a photo, then seems to fail to actually store that anywhere in the EXIF data. exiftool can’t find it, anyhow. OTOH, now that I have the Hazel/imgup folder going, I can process images-to-snippets from any photo tool, and Photos was at least amenable to making a QuickAction to dump the selected photo into the upload folder. I just end up having to add the caption after the snippet is made, and my SmugMug photo hygiene suffers.

(Update: Apple Photos actually does seem to set the field, but my code was exporting the original photo, and Apple seems to treat any metadata you add in Photos as a non-destructive change, so you have to disable the “original” flag in the AppleScript export.)

I added a format option to the imgup CLI, so it’ll provide a snippet in either org, Markdown, or HTML markup now, matching what it can do from the web interface. Also realized I don’t have a “picture of the week” feature anymore, so I replaced that part of the menu with a direct link to the Smugmug target album in the Smugmug management UI. Great for quickly getting to a bunch of test photos and removing them.

Next on the todo list:

• Wire it into Raycast for quick “upload this image and return a snippet” action.
• Figure out if there’s a way to make a Photos sharing action out of it, too.

To restate the problem imgup started out solving:

You never know what your blog hosting provider is going to do to your photos when you upload them. Gnarly compression, weird image renames, path rewrites, maybe they don’t even support image uploads and you’re left to your own devices for hosting. Move your blog, and the images are probably going to break if you were depending on any provider magic at all.

So … skip all that. If you have an image hosting service you already like, and if they specialize in treating your photographs well, use ’em!

imgup just takes a photo, uploads it to a hidden (but not private) album, and returns a snippet of Markdown, org, or HTML you can paste into your blog post, complete with alt text if you provide it.

The command line tool is a recent addition because the “open web UI, select, upload, copy, paste” workflow is fine given how many steps it saves otherwise, but a CLI option is even more efficient (and automatable).

The thing imgup can’t solve is using it to do something besides share screenshots of things that make blogging easier. Lately we’ve been verging into “blogging about things that make blogging easier” territory, and that feels icky.

• One from a selection of a bag of flour, a bag of baking mix, or a bag of generic corn flakes cereal
• One or the other of a packet of spaghetti noodles or rice
• a can of pureed pumpkin

I had more to keep track of this week, and there was something in the air. The first people to draw numbers for their place in the line got high ones: in the 90s and 100s. They didn’t want high numbers because the better items are long gone by the last 25 or so people, but the food bank folks don’t allow do-overs. Then a general mood hit and everybody started crowding for their number, a few people darted past the line control people and tried to get a second number, and it got a little rowdy.

Once things settled down and people started coming down the line I found it pretty hard to communicate “one from this group of three, one from this set of two.” Most of the patrons are elderly Asian folks, so there’s a language barrier that both sides of the table try to mitigate with broad gestures and repetition.

I realized about five minutes in that the line is just sort of set up wrong for those conditions:

When you have a pair of crates side-by-side with bags of rice in one and bags of noodles in the other and no way to communicate what “one” means in that context when “one or the other” doesn’t mean anything to the other person, there’s a lot of gesturing and a few attempts to just take one of each, and then some unhappiness when you ask for them to put one back (with a lot of gesturing and repeating and some of the other volunteers weighing in because nothing breaks down language barriers like everyone yelling in unison).

So I rearranged my station:

• The flour, cereal, and baking mix all went in one column.
• The rice and noodles went in another column.
• The pumpkin puree just sat there. I said to the coordinator at the start of the shift, “guessin’ that’s not gonna fly off the shelves” and got a wry smile.

Set up thus, I could just make eye contact, hold my hand out over a column, say “one,” and it seemed much more clear that I meant “one from this column.” And that was great, partly because it just helped things move along and partly because having removed the overhead of gesticulating, repeating, and the hurt feelings of people having to put things back, people were more inclined to say thank you, or make jokes about wanting more than one, and I had more time to help them load their bags or remember to hand things over with both hands when they preferred that I hand things to them.

It did mean I had to keep more stuff readily at hand and I had to more frequently re-up my columns, but I think a concentrated 60 or 70 minutes of moving a little quickly for the sake of making it less sucky was a good tradeoff.

This week we ran out of rice early. Plenty of Funyuns, same as last week. The coordinator tells me the money has been drying up, so they can’t buy the staples, but donations of junk food tend to be plentiful.

• Pick an image in photos
• Fire off the action in RayCast
• Select a snippet format of `org` or `markdown`
• Provide an alt tag
• Get a copy/pasteable snippet back from imgup I can drop into the blog

I have a matching one for a selected file in the Finder.

Now I just need to go take pictures.

Partly “why not” and partly “you get real org-capture and it becomes easier to shuttle text around.”

That led to this:

(defun lmno/org-export-blog ()
  "Export ~/notes/blog.org → ~/notes/lmno.md."
  (interactive)
  (let* ((input-file  (expand-file-name "~/notes/lmno.org"))
         (output-file (expand-file-name "~/notes/lmno.md")))
    (with-temp-buffer
      (insert-file-contents input-file)
      (org-mode)
      ;; turn off all the bells that inject TOC, numbers, dates, etc.
      (let ((org-export-with-toc            nil)
            (org-export-with-section-numbers nil)
            (org-export-with-author         nil)
            (org-export-with-creator        nil)
            (org-export-with-date           nil)
            (org-export-with-priorities     nil)
            (org-export-with-timestamps     nil)
            (org-export-with-smart-quotes   nil)
            (org-export-with-broken-links   'mark))
      (org-export-to-buffer 'md "*lmno-export*" nil nil nil nil))
      (with-current-buffer "*lmno-export*"
        ;; strip the anchors org's export insists on inserting
        (goto-char (point-min))
        (while (re-search-forward "<a id=\"[^\"]+\"></a>" nil t)
          (replace-match ""))
        ;; strip the overhelpful datestamp spans
        (goto-char (point-min))
        (while (re-search-forward "</?span[^>]*>" nil t)
          (replace-match "")))
      ;; write out the clean Markdown
      (with-current-buffer "*lmno-export*"
        (write-region (point-min) (point-max) output-file)))
    (message "Clean export complete → %s" output-file)))

It has to do two things I wish it didn’t:

• Find and replace a bunch of anchor links org’s HTML export drops onto headings
• Find and replace a bunch of spans org’s HTML export wraps around what it considers datestamps

But then it just plops the whole monolith into the Markdown file I can drag into lmno’s uploader.

… then I noticed “the images have no alt tags,” so I found someone wrote this custom org link type:

(org-add-link-type
 "img" nil
 (lambda (path desc backend)
   (when (org-export-derived-backend-p backend 'md)
     (format "![%s](%s)" desc path))))

It just registers a custom org-mode img link, and exports to Markdown with an alt tag, so this in org-mode:

[[img:https://photos.smugmug.com/photos/i-rnGMdNb/0/K3vtM5mZMTn4s9zVwkhdGBXdcBgNPzD74g957cG6J/XL/i-rnGMdNb-XL.jpg][Some alt text]]

becomes this when exported to Markdown:

![Some alt text](https://photos.smugmug.com/photos/i-rnGMdNb/0/K3vtM5mZMTn4s9zVwkhdGBXdcBgNPzD74g957cG6J/XL/i-rnGMdNb-XL.jpg)

… so then I thought, what if imgup could provide not just Markdown and HTML snippets, but also org-mode img link snippets?

(It’ll do that from the command line version, too.)

Fifteen years later, still true.

I got it from Homebrew, and discovered one issue with it, which is that the agent it sets up wants to log to /usr/local/var/log, which is locked down in at least recent versions of macOS (and ignores /opt/homebrew/var/log, which is already correctly permissioned, so now I’m wondering if I have the wherewithal to submit a patch somewhere). So you can either make that directory and set the right permissions, or twiddle the launch agent.

So if one wanted to use something like cielagonote with Gollum and didn’t care for nb as an intermediary, this might be a way to go.

In addition to the daemon, you can also manually fire off a sync, so I can see making a little script for Alfred or RayCast that does a sync before stepping away from a machine.

In the process of debugging the log issue I discovered LaunchControl, which does a lot to make launchd a little more legible with a mildly busy but helpful GUI.

Through this I learned that launchd is pretty irritable with jobs it considers “inefficient” for reasons I am not completely clear on, so I saw watching the Homebrew emacs-plus service failing/starting/failing/starting over and over. From the point of view of someone who is just launching emacsclient -c --no-wait from RayCast, there is nothing untoward going on: It launches in an eyeblink. I did a little reading about what the throttling/inefficiency issue might be, but we’re rapidly getting into the ineffable wisdom/hatred of experts that informs the macOS ecosystem and I think I’m gonna just close that window and pretend it’s fine.

Us: “It’s a UNIX system! I know this!”

Apple: “Whatever, kid.”

#!/bin/bash

# Required parameters:
# @raycast.schemaVersion 1
# @raycast.title Emacsd
# @raycast.mode silent

# Optional parameters:
# @raycast.icon 🤖
# @raycast.packageName Emacs

# Documentation:
# @raycast.description Launch Emacs
# @raycast.author pdxmph
# @raycast.authorURL https://raycast.com/pdxmph

/opt/homebrew/bin/emacsclient -c --no-wait
osascript -e 'tell application "Emacs" to activate'

… and I made another one that lets me trigger git-auto-sync operations when I’m going to step away for a while and want to make sure everything in my notes repo has been pushed:

#!/bin/bash

# Required parameters:
# @raycast.schemaVersion 1
# @raycast.title Sync Notes
# @raycast.mode silent

# Optional parameters:
# @raycast.icon 🤖

# Documentation:
# @raycast.description Run git-auto-sync on notes directory
# @raycast.author pdxmph
# @raycast.authorURL https://raycast.com/pdxmph

set -euo pipefail
IFS=$'\n\t'

# ——— set up a user‐level log directory ———
LOGDIR="$HOME/Library/Logs/git-auto-sync"
mkdir -p "$LOGDIR"
LOGFILE="$LOGDIR/sync.log"

on_error() {
    local exit_code=$?
    local lineno=$1
    local msg="ERROR on line $lineno (exit $exit_code)"
    echo "$(date '+%Y-%m-%d %H:%M:%S') ▶ $msg" >>"$LOGFILE"
    logger -t git-auto-sync "$msg"
    terminal-notifier \
        -title "🔥🤖🔥 git-auto-sync FAILED" \
        -message "See Console.app or $LOGFILE" \
        -sound default
    exit $exit_code
}
trap 'on_error $LINENO' ERR

{
    echo "=== Sync started at $(date '+%Y-%m-%d %H:%M:%S') ==="
    logger -t git-auto-sync "Sync started"
    cd "$HOME/notes"
    /opt/homebrew/bin/git-auto-sync s
    echo "=== Sync succeeded at $(date '+%Y-%m-%d %H:%M:%S') ==="
    logger -t git-auto-sync "Sync succeeded"
} >>"$LOGFILE" 2>&1

terminal-notifier \
    -title "🤖 git-auto-sync" \
    -message "Sync complete" \
    -sound default

It uses terminal-notifier to let me know things either worked:

… or didn’t:

I pinned both actions to the top of my Raycast window:

Left to its own devices, git-auto-sync does its thing every few minutes. This is just a way to know it’s safe to close the laptop if I’ve been working in my notes.

I really like Raycast. The number of supported apps in the store is pretty impressive, and there’s a nice SDK/API for making GUI tools. My work Asana is much easier to deal with when I can make a card without having to actually be in the Asana web app, and without having to deal with a plaintext syntax to express which project/board, who owns it, the deadline, etc.

I took it to see X a few weeks ago and it was fine from the front row. There was a guy standing a bit forward of me who also had an X100VI, and he was doing a lot of double-exposure stuff that involved waving the camera around for a slow exposure, then taking a faster one. I’m sure the effect is neat, but one drawback of the X100VI is that the rear panel doesn’t fold in, so if you’re a “preview via the rear panel” person, everyone’s getting a face full of that unless you turn off the rear display, which I will do once I remember all the possible combinations.

Anyhow, I got a lot of shots I was pretty happy with for being behind a rail, and the 40MP sensor lets you crop a ton.

I also took it to see Mutoid Man at the Twilight Cafe, and that was a much bigger win for the small size. It was a pretty crowded, excited room and I was pressed against the low stage, so I kept the camera close with an eye out for the mosh finding me. I guess, as that picture shows, I also liked that the small size let me do some discrete documentary shooting waiting for the show to start.

The stage at the Twilight Cafe was much less well lit than the Crystal Ballroom, and I keep auto ISO set to go as high as it needs while holding the shutter speed to 200. That meant an ISO of 3200 for most shots, which is noisy but fine for the subject matter.

I experimented a little with face detection AF and got mixed results. I was much closer to Steven Brodsky than I was Jeff Matz, and sometimes – maybe due to the lighting and motion – the AF would target Jeff, which wasn’t great with a wide open aperture. I think I may map one of the buttons to toggling that on and off if I see it getting flaky. I don’t tend to trust AF much beyond “set to a small point, set that point manually, don’t do subject detection.”

Then there was Silver Lake, who performed in a small bar/guitar shop. It was super crowded and I hadn’t meant to take many pictures, but Al asked me to for her friend. The light was mixed and it was super crowded so I had to shoot over peoples’ heads. I was glad for plenty of megapixels to crop because I was so far away, and I was glad for the small size because it was a pretty intimate setting and there was already a videographer at work. Face detection was much more reliable in that setting, too. Every now and then it sort of hunted between the lead singer and the bass player because they were right next to each other.

For both Mutoid Man and Silver Lake I could have brought along either my Olympus with its f1.4/20mm or my Fujifilm X-T5 with its f1.4/33mm and might have liked having a little more light-gathering, but the X100VI works fine for what I’m doing and doesn’t look threatening to security. I just want to work on quieting down that rear screen.

With emacs-plus, I think I’ve found the thing that most conforms to what I’m willing to be patient with. Enough so that I was able to make a simple Raycast launcher that wraps emacsclient -c --no-wait (and could easily make something similar for Alfred or just an Automator app) then hide the Emacs.app from possible completions, and I can get a fresh Emacs frame as close to instantaneously as I care to imagine, without a lot of hassle. I tossed in a quick osascript at the bottom of the Raycast launcher script to make sure my new frame gets focus right away.

Unlike running (server-start) inside my init file, the combination of emacs-plus and a service is immune to accidentally bonking my entire Emacs instance: The daemon still toils away in the background even with errant cmd-q’s. I know there are recipes for homegrown launchd services and that none of this is new. I guess the nice part is knowing that this is all packaged up and tested.

A lot of people are very into the fact that it uses org-mode underneath. I am, too, because unlike Markdown, org-mode is super amenable to a variety of plaintext workflows that you could probably pull off with Markdown but without all the supporting infrastructure to make it easier.

Take, for instance, the small problem of recreating reverse-chronological posting to a file:

Part 1. Content authoring vs. information management

When I wanted to do that with org-capture and Journelly, it just took this:

(after! org
(add-to-list 'org-capture-templates
'("j" "Journelly" entry (file "~/journal/Journelly.org") "* %U @ Home\n%?" :prepend t)))

… because org-mode provides a ton of infrastructure, including the ability to assume that if I tell an org-capture template to prepend to a given file, it will know to skip all the metadata at the top of the file and just plop the new level-1 entry on top of the top-most heading. Done. (Though I didn’t realize prepend was that clever, so I’ll just not show the eight or ten lines of lisp I thought I needed to do that with before Álvaro kindly straightened me out.)

I guess the thing about org-mode is that it’s not just a kind of markup, but is also an information management framework and its internal tooling has grown up to reflect that.

But when we take the use case of reverse-chronological posting to a Markdown journal, it can get dicey. The infrastructure really isn’t there, because at its core Markdown is just there to ease authoring, not management. I once ran a team of technical writers who struggled with The Markdown Revolution, because technical writers are also technical information managers who want to think in terms of efficient content reuse and refactored and recombined information. They ended up migrating to DITA (sit with that home page for a while), which was hugely alienating to the developer teams they worked with, but which allowed them to do stuff like localize their docs or effectively refactor documentation for a bunch of different kinds of presentation. I still grind my teeth on their behalf when I run into Markdown reductionists.

Anyhow, the reverse-chronological posting thing in Markdown:

There are three ways assorted Markdown systems I’ve come across handle how to set the title of a file.

YAML (or TOML) frontmatter:

---
title: "This pretty good file"
---

“The first H1 is implicitly the title”:

# This Pretty Good File

… and even one “piece it together from the slugified file name” case I spotted somewhere:

this-pretty-good-file.md

… which makes my gums itch.

All of those require some footwork to get a new Markdown H2 wedged into a file, and because Markdown is fragmented all to hell in part to solve information management problems it wasn’t designed to consider in the first place, there is no general-purpose solution. The best you can do is pick how you’re going to do it and build your tools accordingly.

In a situation where you’re making a logging tool, I imagine most people would just punt and append to a log file and live with chronologically-ordered entries. I happen to like reverse-chronological logs, so I made md-capture.el to recreate the org-capture experience in Markdown, and it is 105 lines of Emacs lisp that is to org-capture as a donkey in a dead lion’s pelt is to Aslan. If anything, md-capture convinced me that I should just use org-mode for any writing I care about and that needs to be part of a larger body of writing or interact with other parts of that body.

Part 2. You don’t have to care about any of that with Journelly

org-mode’s “problem,” to the extent it has one, is that it’s a creature of Emacs and lisp, so it inherits their marginalized status. It was sort of fun when Puppet started using Clojure, because overnight I started seeing Spacemacs start popping up on developer screens: lisp was back! As someone who’d been thinking of Emacs as home since 1992, I felt vindicated!

Talking to a Puppet product manager in the ensuing years, how much of a win that shift was for anyone is an open question: Even Puppet’s traditional Ruby foundation was a touch exotic for the average sysadmin who might also be willing to submit a PR, but was way more legible than Clojure. I don’t know if Puppet was cooling off anyhow, or if Clojure just made it impenetrable to would-be contributors, but the claim was made that community contributions to the core seemed to drop off with Clojure.

Well, anyhow, you don’t need to understand org-mode to get benefit from Journelly. This is the third tool Álvaro has made that bridges the world of org-mode with iOS, and does so in a way that lets “app people” just have an app they can use, while “org-mode people” can take advantage of the wider org-mode ecosystem if they so choose.

There are other org-mode “bridge” apps out there, but my observation has been that even with a touch-driven GUI they seem to prefer to expose the functionality in a way that is still visually anchored on org-mode as a way to markup text for information management. Journelly, along with Plain Org and Flat Habits, does a great good job of “just working” without needing to know about all the infrastructure available to you if you care to use it, and without making you deal with UI elements that want to remind you of their plaintext counterparts. Technically its use of hashtags probably counts as an extension of org-mode, since they’re not, as near as I understand, in the org-mode spec. In day-to-day use with standard Emacs tools, I’m not sure how much it matters.

So with Journelly we get an app that a non-Emacs person who just wants to have a flexible, elegant journaling tool can pick up and use: It has hashtags, you can add pictures to your entries, there’s search, etc. etc. and you don’t need to know about the plumbing that holds it all together. You still benefit, because if Álvaro announced tomorrow he was done with it and pulling it from the market, your stuff could be exported into a format that might not be popular but that is easily processed into something that is by Pandoc.

Part 3. Forgetting the plumbing helped me use Journelly better

So I mentioned that I’m not sure about the place of #hashtags in the org-mode specification.

“Tagging” in org-mode happens at the heading level:

** This is a sub-heading about particular fruits :grapefruit:citrus:

When you search for tags in assorted parts of the org-mode ecosystem, you are searching for :tag:, and :tag: occurs at the end of a heading.

The social-media-era #hashtag doesn’t exist in org-mode, so you don’t get any of the org-mode infrastructure benefits of using them in an org-mode file. They’re still perfectly searchable as a matter of being a string that starts with #, but org-mode has no place for them semantically. People have behaved unpleasantly to each other about this.

When I first picked up Journelly, I remember seeing the little # button, and not even knowing how to process it, because I knew Journelly was using org-mode underneath. So I ignored it. I was sort of excited that there was this very friendly journaling tool that I could use as a plain old mobile app, and that underneath it had this familiar, feature-rich format if I wanted to do something with my data in Emacs. In my mental model of how to use a tool that uses org-mode underneath, I was doing the same thing some other org-mode app designers have done, which is try to exist inside org-mode’s markup model.

I don’t even know why I decided to see what the # button would do. I think I had just downloaded the latest Testflight beta and maybe tags were mentioned. Maybe I was bored. So I tapped it and added some text and saved the entry. Oh … huh … that text had become a tappable link that listed my one entry with that #tag. So I went back to some past entries and stuck some tags in and proved to myself that #tags do something in Journelly that is technically a divergence from org-mode proper, but which are useful and intuitive in the app context.

It was the “technically a divergence from org-mode proper” part that stuck with me, because in the moment I had to make a decision, I guess:

Ignore #tags because they wouldn’t work quite like :tags: in Emacs, or accept them in the context of Journelly because they’re useful.

An exchange I’d had with Álvaro gave me another useful nudge. I was trying to solve the problem of how to edit my Journelly file from the desktop without blowing it up in a sync error, and sort of problem-solved my way into thinking it’d be interesting if Journelly could handle multiple files and maybe interleave them since the entries are all predictably time/date-stamped. He said he liked having a monolithic file because he could find everything with swiper searches. I’d never used it myself, but I had my Doom config going and it’s already wired up with SPC-s-s (or SPC-s-S to search for the thing at point), so I learned it’s a fuzzy search tool.

Well, there’s your “how a #hashtag would work in org-mode” solution: It’s just text. Use a native tool in the context of a monolithic journal. And there are plenty of other fuzzy search tools for multi-file search.

So I got unstuck on using hashtags in Journelly and decided Álvaro wasn’t trying to embrace/extend/extinguish org-mode to build his app empire.

Part 4. mindful journaling with hashtags

Which is what brings me to something I’ve never used a journal for before: Checking back in on how I think or feel about something, which I stumbled into.

Once I decided to start using hashtags in my Journelly entries, I wasn’t sure how to use them. Semantically, in a social media context, they are a discovery tool. I’ve read it recommended that if you’re using Mastodon you should really lean into them, because say what you will about the toxicity of algorithmic discovery, without it you need to figure out some other way to discover stuff.

I won’t use Microblog because it has taken the position that hashtags aren’t okay, and the one time I mentioned the discovery use case I got a snide “why is it so important to be discovered?” from the founder that was just … like … because I want my writing to be discovered by people who may share my interests or even express appreciation for my writing or photography or other endeavors. Why the fuck do you have a first and last name, asshole? For a period I wedged hashtags into my Microblog blog with a Hugo shortcode that linked to a Mastodon search for a given tag and a custom social posting feed that made sure the tags were injected into the description, but decided if a service has set aside a very basic and commonly understood tool for discovery because the founder thinks hashtags ruined Twitter, why bother?

So I was just putting tags on all sorts of things to see what would stick: People, moods, places, kinds of events, themes, etc. etc.

The most useful pattern to emerge was completely coincidental:

I was struggling to manage interactions with someone at work, to the point I was dreading every call or meeting. I had deeply internalized the idea that this person was impossible. If asked “what do you think of this person,” I’d have described someone who could not be worked with, would not respond to basic interpersonal communications strategies, and for whom I’d resigned myself to merely co-existing.

Over a few weeks, as I’d come out of meetings or interactions, I’d do my best to remember the positive parts of the interaction: Things where maybe they were their usual intransigent self, but had surprised me by showing up better, or responding well. But when talking about them over dinner, after work, my “they’re impossible” narrative would crowd out any in-the-minute observations.

Then one day, having just finished a post-meeting entry, I tapped on their name hashtag and got all my past entries where I’d mentioned them, and had a ton of evidence in front of me that for weeks I’d been seeing good things, positive signs, indications that they were not, in fact, impossible or hopeless. That most of the time they were showing up okay. The “omg nothing good came of that” entries were pretty sparse.

I guess if I were faced with a solid cube with no apparent openings that didn’t respond to anything I did to find out what was inside it, or a solid cube with a small number pad that required a eight-digit pin to open, I’d probably complain that seven digits is a documented boundary of our ability to memorize a string of digits, but would prefer that to not being able to open the cube at all. I would probably save the eight digits in 1Password or write them on a sticky or make a snippet of them.

Which is sort of what using hashtags for a difficult human being helped me do in Journelly.

So it never occurred to me to test what would happen if I had ended up going long and deciding to give myself more screen real estate with C-x 1.

Then I did that and Emacs started squawking about having only one window to close, so even though it was saving my lmno.md file, it was complaining and not closing the posting minibuffer. I thought I fixed it once, but turns out I was fixing the wrong file in the wrong place for another project. Then it complained at me again today so I fixed it for real this time.

The Sublime distraction

While I was In the midst of thrashing around with Emacs configs I wanted to keep working on another project, so I dusted off Sublime Text to just keep moving while I worked through my feelings about Emacs (again). I’ve always had an uneasy relationship with it. I love that it’s fast and smooth and runs on everything in the house, Linux and Mac alike. I love that it’s got a good package ecosystem. I’m not a Python person, though, so if I had an itch to scratch in the form of making my own plugin for it, I’d be back at the bottom of the hill. I liked Textmate back when because I could write my own plugins in Ruby, and I like BBEdit for similar reasons: Text filters can be any scripting language.

But I’m not actually good at Emacs lisp. Not on the level of something like making lmno-blog-capture on my own. Instead I fire up whichever LLM I want to play with and go through a sort of iterative process of describing what I’d like to see happen, then testing it out, then layering on another idea, etc. etc.

That’s time that could be spent getting gud at Emacs lisp, I guess, but when I think about making that investment … it just doesn’t strike me.

I asked ChatGPT to translate lmno-blog-capture to a Sublime Text plugin for me, just to see the code side-by-side, and it was pretty legible. It also took zero iterations to have a working version. Getting an LLM to kick out working lisp on the first go is often hilarious, which makes sense.

Anyhow, nothing to do with it for now. I’ve got this emacs-plus setup in a good place, and there’s usually something that does what I want already in the ecosystem.

Update: I did go ahead and make a package out of the Sublime version because why not. There’s a package file you can download and install in the releases. It’s funny because it is just not my conception of Sublime Text that you’d live in it in this manner, but it seems completely right and proper that the exact same functionality would exist in Emacs.

Alison’s friend Patricia Rojas played a set with her band, Silver Lake, at a guitar shop/bar in Buckman. Really nice Americana.

Then we headed to the Twilight Cafe for Mutoid Man. I was super-excited for that one because I love just that band, and because all three members are in other bands I really love: High on Fire, Converge, and Cave In. They were really, really good and it was a great audience.

• I do not like the daily file-naming convention (yyyymmdd.ext), especially since other files have datestamps in the names.
• I much prefer the daily-yyyy-mm-dd.ext for scanability and fuzzy-finding, and I like the way cielagonote titles the daily file, which matters in some parts of the Markdown ecosystem.

So my initial approach was to tell nb people to just not expect the daily functionality to work in cielagonote, or that they’d just get a daily-yyyy-mm-dd file dropped in their nb instance that wouldn’t work with the daily plugin. I didn’t like that much.

I had a fork of the nb daily plugin anyhow so that I could have my preferred file-naming convention for daily notes using stock nb and I’ve added some configuration logic that lets people go a few ways:

• Use completely stock nb and its daily plugin in or out of cn. On first daily entry of the day, you get dropped into a command line where you can type in your first log.
• Use stock nb with the forked plugin and get the same behavior, but with a more readable file naming scheme.
• Don’t use nb and get the more readable file-naming scheme.

This is all managed with a new daily_format: setting that can be set to either nb or cn to drive how files are named.

Personally, I’m going to use the forked plugin so I can keep using nb for management and git syncing but have more legible filenames for daily notes.

You can install it from the command line with the URL and use it either in the context of cielagonote or just use it alone to pretty up your daily note filenames:

nb plugin install https://github.com/pdxmph/cielagonote/blob/main/extras/cn-daily.nb-plugin

It also adds a warning in the README that nb support is incomplete. I do want to make a config switch for that.

notes_dir: ~/notes
default_extension: md # or org
exclude_dirs:
  - denote
  - .git
hide_hidden: true # hides .files when enabled
editor: micro # will be overridden with `nb edit` if nb_support == true
nb_support: false # if true, overrides your editor: setting and enables nb file management

So you can either just use cielagonote as a standalone note manager with no supporting ecosystem, or you can flip nb_support: to true and it’ll use nb’s native commands to create, rename, and delete notes, ensuring that nb’s underlying git repo stays clean and in sync with remotes.

One bit of config logic: if you enable nb support, the editor cn invokes will be based on your nb setting, not what you configured in .cnconfig.yml. That’s just to be compliant with nb’s expected behavior to keep the underlying repo clean.

… and there’s one tradeoff: nb’s daily plugin expects you to just provide it with an input argument and logs the entry for you in the daily note. I wasn’t aware of the daily plugin when I started using nb and settled into my own daily-yyyy-mm-dd.ext convention. I think there’s a way to address the whole thing that leaves both approaches intact if you choose to turn on nb_support, but for now the README just says “don’t use the ^t keystroke if you’re using nb because it doesn’t honor the nb daily file naming convention.”

I think I’ll stop messing with it for a while now. It does what I want either as a standalone tool for anyone, or as a way to use nb with a slightly different twist on its native behavior. There is an fzf plugin for nb that gives you a fast way to access notes, cielagonote just adds a few conveniences so you can stay in its interface and manage notes a little more visually and a little less “dig up a number, enter a number” to do operations.

Update: Oops. Introduced a regression. 0.7 is the way to go:

Link

• One or the other of a packet of spaghetti noodles or a pound of white rice
• One can of tomato paste, sauce, or diced tomatoes
• One jar of peanut butter
• One or the other from a box full of ramen, canned fruit, and other stuff or baby food, apple sauce, white vinegar, soy sauce and cooking oils

The station to my right had Funyuns and Nerds candies, and they were allowed to give away three of either. The station to my left had assorted meats: Hamburger, chicken thighs, and a few racks of ribs. Further down the way there was a vegetable person who had purple onions and some other vegetables.

The shift started with number distribution: A bit over 100 people lined up, and each got a token out of a plastic bin. The first person got number 1 and that made everybody laugh. The coordinator asked me to please keep an eye out for people slipping past the guy controlling the line to get a second number. Once the numbers were distributed, everyone came back into the area in front of the tent we were set up under and starting filing past.

I spent about an hour pointing to the spaghetti and rice bins and saying “this or that, only one” a lot. Some folks tried to grab both, and at first I’d say “oh, no … just one or the other” but the people on either side of me faced with similar situations just firmly took the second item out of their hands, so I started doing that.

There was a small ripple down the line when someone lifted a pound of white rice out of the bin and discovered a different kind of rice with a more colorful label and maybe more of it. That caused a few people to double back and swap their rice out. When I ran out of peanut butter to distribute one of the other volunteers dumped a box of small Nutella knock-off jars into the bin, which didn’t move super fast. Eventually, I was out of rice, but the Funyun station was in fine shape. I spotted a ton of extra boxes of that behind the line. Thanks, Funyun patron.

After distribution was mostly over a few people who couldn’t get numbers came through, then I helped break down the tents and haul what was left back to the supply room, then grabbed some gloves and disinfected all the meat storage tubs. The coordinator was curious about what I was doing there. Given the application process and time sheet, I guess some volunteers are fulfilling a community service obligation. I just explained that I’d searched for volunteer opportunities, wanted to support the Oregon Food Bank, and saw this location, which is just a five minute walk away. So I think I’ll be going back every Wednesday: I’m giving up my lunch and the company is giving me up from 1-2 in the afternoon.

You can start or add to a daily note in cielagonote with C-t. That opens a file named daily-yyyy-mm-dd.ext (where .ext is either .org or .md depending on what you set in .cnconfig.yml).

That’s the naming convention I’ve been using forever for daily notes, and is at odds with nb’s own daily plugin, so I forked that and added it to the cielagonote repo as an extra.

$ nb plugin install https://github.com/pdxmph/cielagonote/blob/main/extras/cn-daily.nb-plugin

$ nb help daily for usage, but nb daily 'log text' will get you going.

I think next up should probably be the config switch for “fully in the nb world” vs. “just doing your own thing.” That would just mean adding a line to the config file to set that switch and changing the behavior for:

• deleting notes
• renaming notes
• daily notes (to conform to the stock nb plugin)

… to use the stock nb commands for those things under the hood, which will trigger nb syncs and reduce the chances of collisions if you’re the type to walk away from an open buffer.

As a matter of tools therapy, I’m enjoying this little project. It all starts from the assumption that you shouldn’t care too much what you called the things you stuffed in the shoebox, you should just be able to find them, and you should be able to make new ones that might as well be consistently named but don’t have to be. That has created a sense of lightness in daily usage, even as I enjoy thinking about how to keep it all that simple but layer on ways to interact with it efficiently.

• LSP
• Vertico
• osx-clipboard
• exec-path-from-shell
• recentf
• company
• orderless
• which-key
• marginalia
• evil
• prescient
• undo-fu
• lmno-blog-capture

There are 269 lines in my tangled config file to make it all work, and it seems to take somewhere around 0.7 seconds to launch from the shell (more like 1.3 seconds as a GUI). I had 387 lines in my Doom config, which is honestly a decent reflection on Doom: You can go totally “kid in a candy store” with that thing and it’s doing a lot to help you suffer less for that impulse.

I am probably not done adding stuff. Most of what’s in that list is stuff I got used to in Doom (in significantly less engineered form than you get there). I was mildly surprised to realize how much I’ve gotten used to evil, but after an hour of blundering around and leaving stray ^, $, x, and p in my documents, I broke down and installed it.

The net result of the whole thing today was one of feeling uncluttered. Like, there are things I never really learned how to do with Doom because there was so much to do, and because I couldn’t understand why it was doing some of what it was doing out of the box. The value of taking a step back and just putting back the things I noticed and liked includes knowing why things are doing what they’re doing, and feeling significantly less like my editor is a mysterious box of perils and wonders. And less like an attentional honeypot.

The script on the receiving end:

#!/opt/homebrew/bin/bash
url=${1)
/opt/homebrew/bin/nb ${1}

Tailscale makes this kind of thing easier. (And yes, use an ssh key.)

The problem with that idea was how cumbersome/tedious it was to upload things to SmugMug, grab the URL for the image, etc., so I made imgup to solve that: You just give it an image, a caption, and a title, and get back a link to the SmugMug-hosted image along with all the markup for copy/paste into a post, either as Markdown or HTML. There’s a history page with recent uploads, too.

I recently migrated it off of its Heroku hosting and into Docker on my Synology, and I’ve been especially glad for it since starting to blog on lmno, which offers no image hosting of its own, but I’ve also wanted to be able to run it as a CLI app, so this evening I got around to making that interface for it.

It just takes a --title and --caption along with a filename and returns a Markdown snippet:

$ imgup -t "Breakfast at Grits 'n Gravy" -c "Saturday morning breakfast" /Users/mph/Desktop/IMG_0627.jpg

![Breakfast at Grits 'n Gravy](https://pix.puddingtime.org/Uploads/n-47GBfb/i-CDnXqDV)

… which gives me this:

The home screen of the web interface:

… and recent uploads, with snippets ready for copy/paste as either HTML or Markdown image tags:

At the beginning of our relationship I would feel attacked, because it’s so easy to get so far out to sea that you lose sight of that initial thing that started the process of piling up fixes and solutions and almost feel like you didn’t even know what problem you were trying to solve, you just sort of got caught up in all that change-agent energy and felt like doing something.

So, re: fiddling around with micro to make it behave more like Emacs, the real problem I was trying to solve was how to get in and out of an editor quickly without dealing with a lot of infrastructure and assumptions.

So I moved my Doom Emacs config out of the way and made a very small one.

I know, I know. We’re in Battlestar Galactica territory. This has happened before, it will happen again: Then the layering on begins and soon we have a teetering edifice of bespoke config that becomes harder and harder to manage so we cry out for help to one of the frameworks to save us from ourselves.

I think the interesting thing about the past several days of iterating on cielagonotes is that once I had it into a useful state and was not only iterating on it but using it to jot things down, I felt sort of relieved. And once I found that fzf plugin, I felt even more relieved, because just typing nbf into a shell prompt and getting to what I wanted to get to felt like a reconnection with the problem I was trying to solve. I like some of the stuff I’ve added into cn, but that plugin solves the vast majority of the problem.

And it’s not that I don’t want an Emacs-class editor in the mix somewhere. As I was writing down some stuff I’d learned yesterday I found myself missing stuff you wouldn’t think twice about in an Emacs-class editor, but that isn’t really stuff you need massive infrastructure to achieve. Like inserting another file into the current buffer.

So, here we go again.

This morning I started off with a zsh wrapper around fzf and nb for finding and editing notes. nb is fine and all, but I really like the sort of speedy narrowing you get from something like deft or other members of the Notational Velocity family tree.

So I was looking for something to wrap around nb to keep taking advantage of its git syncing and a few other features, but also warily eyeing too much dependence on it. If the Giant nb-Eating Space Goat were to pull into orbit tomorrow, I would want to simply watch it magestically devour nb, then have a quick way to write a note about my impressions of the experience without accidentally naming that note the same as another about a similar experience.

So you just get the basic “fuzzy-searchin’ notes” thing:

• Start typing
• full-text search narrows your options
• Hit return to pick one and start editing or ^n to make a uniquified duplicate title for whatever reason I was worried about that.

It doesn’t do deleting or other management (yet).

There’s a config file:

notes_dir: ~/notes
default_extension: org
exclude_dirs:
  - denote_archive
  - .git
hide_hidden: true
editor: nb edit

If you set your editor to nb edit you can be assured your stuff is getting synced. Pick something else and it’ll just manage a directory of notes.

hide_hidden: just means “no dotfiles.” exclude_dirs means what it says.

One thing I probably ought to do is ask what file extensions you’d like to see. Since this is for me, it just has .org and .md hard-coded.

Down here way under the fold, probably also good and proper to note that this was mostly me fumbling around and getting help from ChatGPT. I knew the pieces I wanted to glue together, and I knew how I wanted it to behave, but it took a lot of prompting and nagging. And it’s not a new idea. I just couldn’t find anything that did exactly what I woke up imagining in a terminal.

There are two things that I would love to polish up but probably never will:

1. Since I am a heavy emacsclient user, I run into some interactions between it and kitty that leave the terminal in a disordered state. I’ve solved that with a reset after exiting an edit operation. It adds a small bit of latency to an otherwise zippy interaction.
2. The rename and delete operations drop you back into the command line for a second. It’d be a lot spiffier if that were handled more nicely.

On the other hand, this is 233 lines of Ruby and an off-the-shelf cast of supporting characters. It was pretty delightful to use it in anger a few times with my topic logs this morning, and it did what I wanted by feeling way less in the way and less “now I am entering into some other place and descending down into a corner of it and doing a thing and coming back up out of it.”

This has also been piquing my interest in micro. There are some good features there, and it is super fast from a standing start, but it feels less like a rabbit hole.

Oh, right: cn 0.2.0 is also set up as a gem now. That was sort of fun to figure out, too.

{
    "\u001b\u003c": "CursorStart",
    "\u001b\u003e": "CursorEnd",
    "\u003cCtrl-x\u003e\u003c0\u003e": "Unsplit",
    "\u003cCtrl-x\u003e\u003c2\u003e": "HSplit",
    "\u003cCtrl-x\u003e\u003c3\u003e": "VSplit",
    "\u003cCtrl-x\u003e\u003cCtrl-c\u003e": "Quit",
    "\u003cCtrl-x\u003e\u003cCtrl-f\u003e": "OpenFile",
    "\u003cCtrl-x\u003e\u003cCtrl-s\u003e": "Save",
    "\u003cCtrl-x\u003e\u003ch\u003e": "SelectAll",
    "\u003cCtrl-x\u003e\u003co\u003e": "command:fzf",
    "Alt-/": "lua:comment.comment",
    "Alt-a": "lua:snippets.Accept",
    "Alt-b": "WordLeft",
    "Alt-d": "lua:snippets.Cancel",
    "Alt-f": "WordRight",
    "Alt-s": "lua:snippets.Insert",
    "Alt-v": "CursorPageUp",
    "Alt-w": "Copy",
    "Alt-x": "CommandMode",
    "Ctrl-a": "StartOfLine",
    "Ctrl-e": "EndOfLine",
    "Ctrl-g": "Escape",
    "Ctrl-k": "CutLine",
    "Ctrl-r": "FindPrevious",
    "Ctrl-s": "Find",
    "Ctrl-v": "CursorPageDown",
    "Ctrl-y": "Paste",
    "Ctrl-z": "Undo",
    "CtrlP": "command:palettero",
    "CtrlSpace": "command:palettero",
    "CtrlUnderscore": "Undo",
    "F1": "command:cheat",
    "F12": "command:makeup",
    "F4": "command:jumptag",
    "F5": "command:runit",
    "F9": "command:makeupbg"
}

I used to use jed for this, until something went wrong with it for a while. It seems to be operating correctly again to judge from my latest pull down from Homebrew, but I just went to this trouble with micro …

Anyhow, I realized a few things got left out there, so here’s a gist with a more complete set including Emacs-style C-_ undo and Alt-< Alt-> top/bottom of the buffer.

alias nbf“nb fzf”= if you’re feeling frisky.

Done.

I mean, not really, because cielagonote does the whole “make it if it doesn’t exist” thing, and it’s doing full-text search. But if the thing you don’t like about nb is “list, get a number, enter a number” to operate on your file, this does the job.

#!/usr/bin/env bash
###############################################################################
# fzf.nb-plugin
#
# FZF Plugin for nb
#
###############################################################################

# Add the new subcommand name with `_subcommands add <name>`.
_subcommands add "fzf"

# Define help and usage text with `_subcommands describe <subcommand> <usage>`.
_subcommands describe "fzf" <<HEREDOC
Usage:
  nb fzf
  Description:
    Search through current notebook using fzf and then edit sepected item.
HEREDOC

_fzf() {
  local note=$(_ls -t note --filename -a --no-footer --no-header --no-indicator --tree | fzf --ansi --header "$(_notebook current --name)" --preview "echo {} | sed '"'s/\x1b\[[0-9;]*m//g'"' | awk -F'[][]' '"'{print $2}'"' | xargs -n 1 nb show -p | ${NB_MARKDOWN_TOOL:-bat} -" | awk -F'[][]' '{print $2}')

  if ! [[ -z "$note" ]]; then
    command nb edit "$note"
  fi
}

Getting this to work with emacsclient wasn’t great, and in fact it does not work with emacsclient right now. I’ve been playing around with micro and that was great for getting this far with the experiment. Not sure I’ll keep it but one of the things I was trying to figure out when I stumbled across nb (again) was “has anyone done a TUI Notational Velocity”? I haven’t found anything like that, exactly, but it is pretty cool to me that with fzf, fd, and micro, you can get most of the way there with a zsh function.

Anyhow, I need to catch up on some stuff today.

# ~/.zsh/functions/znotes.zsh

zn() {
  local notes_dir=~/notes
  cd "$notes_dir" || return 1

  local files
  files=$(fd --type f --extension org --extension md --exclude denote . "$notes_dir") || return 1

  local file
  file=$( (echo "[New Note]"; echo "$files") \
          | fzf --prompt="Edit or create note: " \
                --preview='[[ {} == "[New Note]" ]] || bat --style=numbers --color=always --line-range=:100 {}') || return 1

  if [[ "$file" == "[New Note]" ]]; then
    echo -n "New note title: "
    read -r title
    [[ -z "$title" ]] && echo "Aborted: no title given." && return 1

    nb new --title "$title"
    echo "Note created. You can run \`nb list\` to see it."
  else
    nb edit "$file"
  fi
}

So log2file takes both of them and adds a few functions + Custom settings to add and remove files from your list of targets: No fiddling with your org agendas, no editing your config file if you decide to add a file as a target, and it speaks both Markdown and org, picking a log heading format based on the file extension, and enforcing the presence of either a first-line l1 heading or org #+TITLE: line based on the filename if it doesn’t find one.

I don’t think I’ll do much more with it. The point of embarkation on all this, as I sort of failed to come back around and make clear yesterday, was that I have a simple set of requirements:

• Keep it in plain text
• Favor a logging/journaling approach
• Avoid anything that feels fragile or complex

On that last point, almost everything these days feels fragile, where “fragile” is a function of:

• Depending on rigid formatting conventions (filename, metadata, inline syntax of any complexity)
• Depending on a specific app to interact with the data

… and from those requirements I didn’t feel like much of anything these days works for me. My grandmother once got very, very angry with my father for splurging on a $10 Christmas tree when we went home for the holidays, because she was a dirt-farming Depression survivor and frugality had been etched into her bones. I’ve just had seemingly simple shit break on me in a way that is stupidly and frustratingly disruptive when you suddenly realize the underlying complexity of the tools supporting the workflow is going to make it hard to just pick up with a text editor and no supporting automation.

So where I started with this was just a collection of yasnippet and Espanso snippets that aped the Journelly log format:

• Open a log file
• Trigger the snippet
• Enter the text
• Save/exit

But I was really inspired by org-capture, which wrings out a ton of the friction in routing text to a sensible endpoint. The problems with org-capture were:

1. org-mode dependent
2. Complex, in that it was beyond my skill to populate a custom list of targets, and I hated the idea of manually keeping a target list in a capture template.
3. org always beguiles me into more and more complexity and “just one more thing”

So this is a way to get some speed back into the interaction … no finding/opening/snippeting … but in a way that doesn’t leave me dependent on a bunch of fragile stuff.

I’ve been on a small tear with these things lately, and whenever I go on a small tear I think “this is happening for a reason,” and the reason is usually “because there’s something you don’t want to go do,” and that is true here. But I like times like this, because they exercise part of me that doesn’t get exercised much: I spend a lot of my day thinking “will this scale,” and “but do we really need to do this,” and “what is security engineering going to do when they find out this happened,” and “did I make Compliance angry.”

And I’m feeling sort of engaged with the problem of “what’s just enough structure for the few notes I keep without freaking out and tipping over into Some Whole Paradigm,” because every time I tip over into Some Whole Paradigm I’m, like, “well now what?” All my brain power went to Learning the Whole Paradigm and I don’t have any left to do stuff I should be doing.

Citing inspirations

A few people and things have been inspiring for me on this week’s jaunt into plaintext living:

• I really dug an old take from Jack Baty on using Deft to manage little topical journals. Just, “make some files about topics, write logs in them.”
• I am really into lmno.lol maker Álvaro Ramírez’s Journelly. As an app it’s great, and as a concept it’s cool: Underneath the friendly iOS skin, it’s just dropping entries into an org file that you can also work with from a desktop machine if you like.
• lmno.lol itself is a variation on that theme: Just put a datestamped entry in a Markdown file that your entire blog lives in.

These things are all very simple to do. Jack’s approach just wants text files. They could even be just text files with no markup.

Journelly has to have some markup, and it is a whole app that relies on a ton of assumptions about how to move files around over a network, etc. but if your phone broke and all you had was, like, nano, you could keep on journaling.

lmno.lol? Your whole blog is in a single Markdown file. You have to know the date and the “#” key, and you’re in business.

How it all went to hell

Let’s travel back in time to, like, 2004 or so:

Danny O’Brien gives a talk describing “life hacks,” the spirit of which is probably best captured by Cory Doctorow’s contemporaneous notes. Everyone went bananas over the idea that you’re really better off not complexifying the shit out of everything, then set about complexifying the shit out of everything.

I mean, we’re dealing with a population that does the whole knowledge work thing, and a distinguishing characteristic of knowledge workers is that they spend a lot of time learning and living in systems. We have the whole idea of a professional managerial class:

“… salaried mental workers who do not own the means of production and whose major function in the social division of labor may be described broadly as the reproduction of capitalist culture and capitalist class relations.”

It was once suggested to me that where “professional” once meant “a job where someone could get sued for malpractice” (doctors, lawyers, architects), it has come to mean “someone who is reliably aligned with the values of the capitalists they work for and behaves in a manner that is comfortably predictable to capitalists.”

Point is, tech industry people live within kind of complex systems: They have to manage complex models to do their actual productive work, and they have to navigate complex functional relationships to deliver things. I still get a little swimmy in the head when I think about one place I worked deciding to embrace Scaled Agile, and I get outright nauseated when I remember a dear friend excitedly talking about “taking the whole business Agile. All of ’em! Especially the marketing team!”

So they can’t really be expected to keep things simple. Part of their value is in their ability to behave predictably when confronted with complexity, so they have to like it at least a little.

So I’m stealing

I’m not sure where I’m going to end up, but I do know at this point:

• Plain text files are good.
• I’ve had success in the past with variations on interstitial journaling, which is what Jack’s idea is most like.
• I really took to the “stick something in a file and keep moving” opportunity Journelly afforded me.
• I don’t want to live in a single text file for everything, but I do want to live in a few text files for most of the things.
• I don’t mind investing some time in a little automation to make it faster to do this kind of stuff with text.

org or Markdown

What I’m really not sure about at this point is the question of doing it in org-mode files or Markdown.

org pros:

• It’s a little easier to add a light layer of metadata to content.
• That metadata layer is optional.
• At its simplest, org is as simple as Markdown

org cons:

• There’s so much there in the way of opportunities to complexify the living shit out of it
• Despite a few things like Plain Org, there are not a lot of ways to work with it without Emacs.

Markdown pros:

• It’s everywhere.
• Weirdly, even though there are ways to make it more complex, they almost always suck because there are so many variants that nobody ventures much past the basic spec + a few niceties like checkbox lists when building tools for it, and those extensions are often hideous to look at. They really damage the readability. (org does this, too, but it has things like properties drawers to hide some of that)
• Yes, the previous bullet is a “plus,” because Markdown is sort of antagonistic to much complexity and I think that’s good: I’m a knowledge-workin’ PMC dillhole, too.

Markdown cons:

• Wedging metadata into it is sort of a challenge outside maybe adopting an inline hashtag convention or bolting YAML/TOML frontmatter on (which not all tools will deal with well.)
• Eventually you’ll end up thinking “fuck it, might as well do this in Obsidian,” and then all hell breaks loose: Welcome to “org mode without Emacs, just in an Electron app, but with Markdown.”

Not sure what I’m gonna do, but in a little frenzy of ChatGPT co-piloting, I did come up with a few ways to make life in a few plaintext silos easier:

• org-topic-log just pops open an org-capture-like window that lets you select from any agenda files that have #+FILETAGS: topic in the frontmatter. You can pick any word you like for the filetag. Super simple to invoke it, drop in a log entry, and keep going.
• md-capture does the same thing, except Markdown doesn’t have all the infrastructure org-mode does, so you can either tell it “just use anything in this directory” (messier and messier over time) or specify a file list (a hassle to manage if you make new topics a lot).

I’m just wavering on whether to do it with Markdown knowing, I will regret any attempts to make those notes more complex, or org because it might be nice to have a few of its conventions (knowing its portability will nosedive the more of them I embrace).

Also: This post written with lmno-blog-capture. If you have an lmno.lol blog you can just put it in your load path. If you want to keep up with it, you can add it to Doom’s packages.el:

package! lmno-blog-capture :recipe (:host github :repo "pdxmph/lmno-blog-capture"))

blog-text-art-banner

 _____  _____  _  _____  ______  _   _ ______ ______  _____  _   _  _____  _____  _____ ___  ___ _____  _
|_   _||_   _|( )/  ___| | ___ \| | | ||  _  \|  _  \|_   _|| \ | ||  __ \|_   _||_   _||  \/  ||  ___|| |
  | |    | |  |/ \ `--.  | |_/ /| | | || | | || | | |  | |  |  \| || |  \/  | |    | |  | .  . || |__  | |
  | |    | |      `--. \ |  __/ | | | || | | || | | |  | |  | . ` || | __   | |    | |  | |\/| ||  __| | |
 _| |_   | |     /\__/ / | |    | |_| || |/ / | |/ /  _| |_ | |\  || |_\ \  | |   _| |_ | |  | || |___ |_|
 \___/   \_/     \____/  \_|     \___/ |___/  |___/   \___/ \_| \_/ \____/  \_/   \___/ \_|  |_/\____/ (_) 🔥🤘🏻🔥

blog-about

Hello 👋 I’m Mike. Regularly blogging at mike.puddingtime.org, tooting @mph@social.lol and wandering around in Portland, OR.

This was an opportunity to try out my Smugmug/upload/image snippet app imgup (which it turns out is an amazingly common name for things that make images go up to somewhere else.)