This is a thoughtful piece by danah boyd that gets to some things I’ve been thinking about re: AI.

Whether you are in Camp Augmentation or Camp Automation, it’s really important to look holistically about how skills and jobs fit into society. Even if you dream of automating away all of the jobs, consider what happens on the other side. How do you ensure a future with highly skilled people? This is a lesson that too many war-torn countries have learned the hard way. I’m not worried about the coming dawn of the Terminator, but I am worried that we will use AI to wage war on our own labor forces in pursuit of efficiency. As with all wars, it’s the unintended consequences that will matter most. Who is thinking about the ripple effects of those choices?

There is a lot of commentary in this r/metafiltermeta thread about AI, which was framed from a place of anxiety:

I’m reading about AI’s impact on coding, graphic design, video, motion graphics, architecture and law. I hear proponents say that they think AI will change jobs, and that smart workers will learn how to use it as an assistant, but when I review Silicon Valley’s contributions to labor in the U.S., mostly I see entire fields gutted, and folks moved over to poorly paying gig economy work.

The more thoughtful responses pointed, I think correctly, to the eventual Gartner Hype Cycle state of equilibrium you get to once you get unrealistic expectations out of the way, trudge through the salty marshes of “told you it was all bullshit,” and get to “how is this thing going to be used day-to-day?”

The people at the Peak of Inflated Expectations do what they always do: Try to solve their problems in a manner ill suited to the tool in front of them, or in a manner that is not reflective of the limitations of the model. The chorus waiting for them down at the bottom of the Trough of Disillusionment has no single motivation: Some of it is wise realism, forward thinking, and experience; some of it is whistling past the graveyard or just missing that “productivity gains,” like many things in technology and business, are not a series of home runs and grand slams, but rather singles and the occasional double. Reframed more bleakly, grinding down labor’s ability to resist induced precarity is a game of inches.

Which is the long way around to saying that if the people who are pointing to offshoring and content-farming mania of the naughts and tens are correct in saying they’re the closest analogies we have, and if danah boyd is right that “we tend to optimize towards more intense work schedules whenever we introduce new technologies while downgrading the status of the highly skilled person,” then it’s going to mean fewer people working in AI-effected systems that are biased toward always looking for one more headcount they can get away with removing. It’ll look different from the “prompt engineering” everyone imagines today. It’ll be software companies figuring out how to integrate existing “dumb” systems with generative AI systems acting as synthesizers, with a few humans acting as QA on top of that process, working from a weakened position.

“ChatGPT Is an Ideology Machine”

Jacobin last month:

A wide variety of Marxists have also seen ideology as a form of kitsch. First articulated by the Marxist art critic Clement Greenberg in 1937, the notion of kitsch is “pre-digested form.” Among all the things we might say or think, some pathways are better traveled than others. The form of those paths is given; we don’t need to forge them in the first place. The constant release of sequels now has this quality of kitsch — we know exactly where we are when we start watching a Marvel movie. For Greenberg, the avant-garde was the formal adventurer, creating new meaning by making new paths. Hegemony and kitsch are combined in the output of GPT systems’ semantic packages, which might miss aspects of “the world” but faithfully capture ideology.

My Things link to org stuff

Today I started using the org-protocol stuff I talked about yesterday with a set of regular todos I added to Things. For my daily writing and journaling todos, I captured links to the headings from the org documents and pasted them into the notes field of the Things todo before marking them done. Clicking on those links brings up a new Emacs frame that jumps straight to the heading in the correct file.

That pretty much recreates the workflow I had with Bear and Things for other kinds of task/notes combinations, and it shows me how to use org-protocol and org-capture to do similar kinds of workflows where Emacs participates in the rest of my tools ecosystem.

So, promising trial experience. I’m a little becalmed on heavy-duty task/work tracking right now, so I’m satisfied to just note that the idea works and that I’ll keep using it to find out where the edge cases are: Something always comes up.

The idea that keeps popping up in my head is that a lot of my past “emacsimalism” – a recurring phase I’ve experienced over several decades – was due to the fact that Emacs was pretty much a technology island. The Mac builds weren’t always very good, and the ways in which it could speak to the system around it were sort of flaky. But things like org-protocol and a little bit of utility glue with osascript do a lot to make it easier to find your way into and out of Emacs. You don’t have to make it your everything because it can work well alongside other things that might suit your individual style better. The idea I’m sort of nibbling around right now is that I don’t like org-mode for organization of work and tasks so much as I like it for organization of text and ideas. It’s less “a smarter Things, OmniFocus, or Reminders,” and more “what I wish Ulysses had been.”

Maybe that’s why assorted org syntax implementations in more modern text editors (e.g. BBEdit, Sublime, Atom, VSCode) are always disappointing: They’re usually just syntax highlighting and no smarts. Might as well just be doing Markdown at that point, because the smarts of org-mode pretty much live in Emacs and lisp. Without that, you’re just quibbling over whether a backslash or an asterisk is better emph notation.

Anyhow, we’ll leave it at that until there’s something new to say. I think I’ve visited this topic plenty.

Twitter

I disabled my Twitter account late last month, so I think I have a bit under two weeks for it to fully deactivate. I think I will thread the needle between making an announcement and merely noting that I have embarked on the process of closing my account by making it the last heading of today’s post, unmentioned in the summary.

There’s a needle to thread because my strong preference would be for people to give up on Twitter. So if you’re someone with whom I might have some influence, I’m happy for you to read this and do the primate thing – “Hm, Mike is a thoughtful, ethical person whose ideas I tend to take under advisement, and he sees Twitter as, on balance, negative and harmful, so I will take that idea under advisement, as well.”

That’s all.

I tried out org-superagenda a while back. It improves on the vanilla org agenda by creating customizable sections, which help it scan a little better. I bounced off of it because while I wanted the quality of life improvements it offered, I was struggling a little with the syntax, and was caught up in that brainspace you can get into where you just want the thing to work and it’s throwing off your sense of time and perception of the required investment to make it work.

This morning I was looking at my agenda and hating it because it was in a “mostly correct except where it is glaringly incorrect” state, so I figured it’d be a good practical task to throw at ChatGPT:

Describe an orgmode super agenda configuration that shows habits, important items, overdue items, and items due in the near future

I got a copy-pastable example that met the requirements.

Could you add items due today to that list

Yep. That worked.

could you move the today list to second place and add a list at the bottom of unscheduled todo items

That response worked well, too. It does a decent job of explaining what each piece of the solution does.

Using the org agenda

Figuring out the org agenda has been key to how I use the tool.

With a good agenda setup I can feel pretty on top of things. When it’s broken I know there are things out there in my file collection that I’m not going to see. As I’ve leaned into org capture, that’s become even more true, because capture buffers keep you out of the file you’re adding something to: You don’t see the other things in there because you don’t go past them to get to where you’re adding new content.

Besides surfacing stuff, the agenda is also the nerve center. You can do basic scheduling and status changes from it, and maybe even more importantly for a sense of organizational calm, you can refile from it. So rather than visiting each file to find stuff and move it around, you can see it all from the agenda overview and refile it from there.

With a restored agenda, I made the connection between my literate Emacs config and all the other stuff flying around in my org mode ecosystem: Links I gathered about configuration tweaks or things I’d like to try can more easily go into a literate config file, so I made an “Ideas” heading at the bottom of the file and started refiling my the Emacs-related things in my agenda’s inbox into my config.org file.

People love hooking into org, too, so even things that started life without org mode in mind can pick up org affinities. The pinboard mode I adopted, for instance, doesn’t natively use org’s link storing function when copying a link, but someone wrote a function to do that. Now I can retrieve a link and add it to a post without taking my hands off the keyboard or switching contexts.

Which reminds me …

I discovered winner-mode today.

It’s annoying when an Emacs mode splits the window into frames, then leaves two frames behind when I quit it. winner-mode “records the changes in the window configuration (i.e., how the frames are partitioned into windows), so that you can undo them.” It’s useful to me because I want to use pinboard-mode as a link retrieval tool for blogging. Once I’ve grabbed the link, I just want to tap q and get back to my blog buffer, not find myself with a split window. winner-mode closes the pinboard buffer, then removes the frame, and I’m back where I left off, able to add my link and keep typing.

Custom Doom keybindings

I’ve been digging Doom’s modal interface, and waiting around for a reason to extend it. Yesterday’s addition of pinboard.el finally gave me an excuse, since Doom was killing its keybindings out of the box.

The p prefix in Doom’s menu system is already occupied by projectile, so I used P:

(map! :leader
      (:prefix-map ("P" . "Pinboard")
        :desc "open Pinboard" "p" #'pinboard
        :desc "open current link" "o" #'pinboard-open
        :desc "copy org link" "l" #'org-store-link
        :desc "edit link" "e" #'pinboard-edit
        :desc "copy URL" "c" #'pinboard-kill-url
        )))

So spc Pp will open the pinboard buffer (or switch to it), spc Po will open a given link, spc Pl will store an org link (for retrieval via spc mll), etc. etc.

One thing I’m struggling with here is a vagary of Doom as an environment. The logical place for all of that is in the bindings.el file, but the bindings don’t “take” when I put them there. They do when I put them in config.el. The docs weren’t super helpful in debugging that, and the things that look syntactically intuitive didn’t seem to solve the problem.

It’s no big deal, and I’d rather just have all of that stuff travel together with the mode it addresses, anyhow, but it’s a thing I Do Not Understand About the Environment except at a very vague “well, there’s a lot of lazy loading going on to keep things fast” level, and it’s going to bother me.

I should just add an INSOMNIA state to my TODO lists and save it for the next “welp, it’s 3 a.m. and I might as well screw around with this problem” session.

Yellowjackets again

Well, we finished the first season last night.

• Standalone season score: 8
• Prospects for the future score: 5

Basically, my “endless puzzlebox” antennae are quivering.

The season all on its own was gripping and kept our interest. I felt invested in the characters and whatever they were dealing with. I love the way it walks right up to the Mandy line a few times. It has a dark sense of humor but it’s not mean.

The 2 missing points for the standalone season score are because it had some minor pacing/bog-down stuff in the middle, and because some stuff going on just felt like gratuitous puzzlebox misdirection. It felt at times like it was written too self-consciously aware of recap culture and a certain kind of mock-obsessive over-read/over-think that comes along with that.

The “prospects for the future” score is a function of how I felt as the credits rolled on the season ender, and it honestly wasn’t great. The episode didn’t feel energetic, it suggested an appetite for “surprise reversal” that will exceed my patience over the long haul, and it reminded a bit too much of the first couple of seasons of HBO’s Servant, which I abandoned with no remorse at the end of the second season.

I feel a little bad about my reaction, because maybe I’m suggesting that television productions should simply abandon the only tools they have to get more seasons. In some ways, they have to pander to recap culture. They have to pander to fannish over-analysis. They have to end each season with a hook and a sense of incompleteness. They have to live within a fickle system run by people addicted to the analytics streaming affords, who will happily kill a property and move on to the next with no sense of investment.

But, you know, don’t point out a problem without pointing out a solution:

For All Mankind (Al prefers to think of it as Space is Trying to Murder You Again This Week) does a nice job with this conundrum: Each season has an arc and a sense of conclusion. There’s payoff. Then it does an end-credits thing where it flash-forwards to the next season’s era and offers you a look. It doesn’t appeal to your thwarted expectations of closure, it appeals to your curiosity.

And to make note of a counterpoint, Succession isn’t above leaving things on a hanging note of tension, but I’ve stuck with it. It’s not terrible to leave things unresolved, or end a season with a directional cue in the form of an unfinished arc. Maybe the thing I’m reacting to with the puzzlebox stuff is the garish palette those shows paint with, swinging for the meme fences.

Anyhow, we have a few episodes of Yellowjackets season 2 cued up. The prospect of watching them, having skimmed a few episode descriptions in Plex, is not sparking a “full-body yes.” There’s just so much other stuff out there that I’m okay with the thought of letting it have its run then deciding whether it’s worth it to watch through the whole thing.

Overall, it was a land of contrasts. It did some things really well, or got to “really well” with a few followup requests. But on the other end of the spectrum it simply invented non-existent functionality then documented how to configure it.

I don’t have any particularly original takeaways. Put me in the broad camp of “human venality is going to be the real problem here,” in ways it already is where other kinds of automation are concerned. We live in a society where people not only, like, read a newspaper in their Tesla, but literally crawl into the back seat and take naps.

The trivial tasks I fed it were limited, so the errors it made were obvious. I wasn’t trying to prove or disprove its … quality? If you’ve ever gotten into an argument with a word processor’s grammar checker you’ll sort of understand what you’re up against in this case, too, with the improvement over that scenario being that instead of staring at the alleged bad grammar and ultimately learning you’re either a “leave the blue squiggles” person or a “can’t tolerate any blue squiggles” person, you can tell it you didn’t care for the answer and it often takes the hint and fixes the problem.

But you have to know that you don’t like the answer. So when it wrote a Puppet module for me and did so with insecure code, I noticed that and told it to do better and it did. Nothing got into production. When it gave me unreadable output for a train schedule, its first correction was at least obviously and intuitively wrong. Nothing got into production.

When I think about more complex code I’ve written the human dimension of the problem stands out more. I once modeled website revenue for a Rails app, which involved a lot of sorting out when data was sampled vs. when it wasn’t, recursive reasoning around costs, etc. and remember the many ways I could lose my train of thought and introduce stuff that looked right even to my experienced eye as a domain expert who knew the problem space as a practitioner and who was describing that expertise in code. No misunderstood requirements, no senior dev fighting with the product owner because reality is stupid, no UX designer arguing that beauty is truth. Just me, passionately invested in the problem, and still introducing errors I couldn’t spot on review … that I could only spot with tedious testing.

Anyhow. Nothing new.

Some of the things I tried:

Create an org capture template for daily health logging

It did the request perfectly, but slightly idiosyncratically for a log format (it stuck the date in the :DRAWER: instead of as an inactive date label in the head). Subsequent conversational-style prompts (“okay, but could you include weight and hours slept?”) caused it to add prompts for those to the template, then “could you make that information that appends to an org table instead” generated a capture template appropriate to appending to a table.

A similar request to create an org-capture template for Hugo blogging was mostly correct, but had a few glitches and the verbose instructions left out a key variable. It was debuggable in a few minutes.

I’d score it pretty highly, and using it for that task is just straightforward “get to the point of the tool, not the labor involved in the tool” utility. Mostly I appreciated that it matched all the parens correctly.

Tell me how to configure OfflineIMAP for use with mutt on a Mac

Did I say yesterday I don’t believe in that? I did. But it was on my mind.

It did this pretty well, delivering instructions tailored to the specific “mutt + offlineimap” use case that were as good as any tutorial, missing only the things that are idiosyncratic to Fastmail, which I forgot to mention to it. I should have thought to tell it I was getting the errors I got to see how it handled that. Instead I just searched for them on DuckDuckGo and got unstuck.

Interestingly, and this happened one other time, I lost the original request to a glitch in the web app. When I restated it only slightly differently … not in a way that you’d think would materially affect the output … it came up with something slightly different that didn’t leave out a key detail the original output did.

I’d score it highly again, minus maybe its willingness to make message deletion live by default without warning. Other examples and tutorials I found mention that.

I followed up by asking it to show me how to capture that configuration with Puppet and hiera, and it produced a serviceable OfflineIMAP module. It would have had me storing my credentials in the plain in the Hiera YAML. I responded that I preferred not to do that so it provided me with an example that used eyaml.

Tell me how to use mutt with a Bayesian filter

It went completely off the rails, inventing filtering functionality for mutt and offering configuration examples that looked – mutt-like? – but inventing a configuration variable that doesn’t exist, near as I can tell, to invoke a configuration file mutt wouldn’t look for to support the non-existent functionality.

Maybe the interesting thing that came out of the interaction was the way it cooked up a mutt-like filtering setup could work in a way that seemed idiomatically correct for mutt. It just did the technical equivalent of adding a sixth finger to the left hand by assuming a generic bayesian filter of some kind and taking the plumbing to connect it for granted.

How would I go about adding a second RSS feed with a different template for a hugo site?

Another miss, with very reasonable-looking instructions that simply didn’t work as proposed. I am not sure how close it actually got. That’s a problem I spent some time trying to solve yesterday and it seemed close but missed some connections between content and template.

It gave its configuration examples in TOML, and responded correctly to a conversational “could I have those examples in YAML” prompt.

Tell me how to write a Sinatra app to download an rss feed, filter it for keywords and save another version of the feed

Prompted by a Mastodon conversation yesterday about RSS readers that could be used to filter sponsored content posts.

Up front, it’s sort of a weird request on my part: I was just lazily typing in part of an idea, including Sinatra as a dependency but not explaining why (my idea would involve creating a sort of RSS proxy with dynamic filtering during each client request). I just wanted to see what it would do without putting a lot of thought into it, or sticking around to narrow things down. So I got a ruby script wrapped in a Sinatra route, honoring the request whether it made a ton of sense or not.

I’ve had it do a couple of Ruby scripts, and it remembered to include `require` lines for gems. It didn’t do that in this case. I added them and it ran. I had to tweak a few things to get it to run without error, and the filtering didn’t work.

I might goof around with this one a bit more to see where it’s going wrong.

This lined up with things I’ve read from others over the past few months: It produced a scaffold of mostly working code. If I decide to mess around with it more, I’ll have been saved digging around for examples of the basic syntax for the assorted parts of the workflow that I know from experience are correct.

“What’s a good strategy for switching between regular and ortholinear keyboards?”

Useless. It provided very reasonable instructions for how to learn how to use an ortholinear keyboard, but didn’t address the actual request.

“Tell me how to write a ruby script to download train times for a given stop in Portland oregon”

It produced working code that showed me the next arrival times for the next train at my neighborhood stop. It provided the correct link to sign up with TriMet to get an API key.

“A-” because it didn’t translate epoch time to human time in the output. When I asked it to do that, it tried to comply and used the obvious syntax to convert the integer it got back from the API, but got confused by the millisecond format.

I tried the code and replied with:

“That time format is still incorrect. I think the timestamps include miliseconds.”

It replied with:

“You’re correct, I apologize for the oversight. It appears that the TriMet API returns timestamps with milliseconds.”

Then it produced working code that did a simple operation on the timestamp and passed it along to Time and strftime with correctly formatted output.

For all of its talents, mutt doesn’t choose to expose any message variables to its macro functionality. If you want to extract a sender’s name or email address or whatever, the message has to be piped. I put something like that together to add senders to a mutt score file, and there are a few other things out there in the mutt ecosystem, like lbdb, that capture email addresses. lbdb could have been great for this, but its whole point is capture to a database of its own.

I’ve been poking around with getting ChatGPT to write little utilities for me, so I put this problem to it, asking for a Ruby script that could pipe a message through formail to extract the needed name and email address.

It took a second prompt – initially it just wrote the code to process the input without specifying the input – but it produced something workable to get the two pieces of data out, and I added an org-contacts template as a HERE doc the script writes into a mutt_contacts.org file. I could have sent it straight to contacts.org but prefer to automate into buffer files to keep the chance of conflicts, sync or otherwise, to a minimum.

The accompanying mutt macro looks like this:

macro index,pager .oc "|~/.mutt/org_contact.rb\n"

I tap .oc when positioned on a message and it pipes into the script.

I’d like to extend the macro to include a quick note, but for now it just adds the NOTES todo state and schedules the entry a day out to remind me to put something in there soon: The new entries turn up in my org-mode agenda for processing and re-filing into my contacts.org file.

And it worked well enough: Once I set it up I was able to run through and add nine or ten new contacts in a few seconds, then visit them in org-mode and refile them all.

And yeah …still holding the line against adding an MUA to Emacs proper. I just don’t want to do the whole OfflineIMAP thing or similar, and I am still keeping things relatively simple. Adding org-caldav today was a small step in the wrong direction, but I like having calendar entries in my org agenda, it syncs relatively quickly once it does the initial download, and it has no system dependencies.

#!/usr/bin/env ruby
require 'open3'
require 'date'
contacts_file = "~/org/mutt_contacts.org"
message_contents = $stdin.read
# Define the command to extract headers with formail
command = 'formail -X From: -X Sender: -X Reply-To: -x To: -x Cc: -x Bcc:'

# Execute the command and capture the output
output, status = Open3.capture2(command, stdin_data: message_contents)

if status.success?
  email = nil
  name = nil
end
  # Parse the output and extract the email and name from the From, Sender, and Reply-To headers
  output.lines.each do |line|
    case line
    when /^From:\s*(.*)$/i, /^Sender:\s*(.*)$/i, /^Reply-To:\s*(.*)$/i
      from = $1.strip

      # Extract the email and name from the From, Sender, or Reply-To header
      if from =~ /(.+?)\s*<(.+?)>/
        email = $2
        name = $1.strip
      else
        email = from
        name = "No Name Found"
      end

      # Found the email and name, so break the loop
      break
    end
  end

org_template = <<~TEMPLATE

  ** NOTES #{name} :mutt:
  SCHEDULED: #{(Date.today + 1).strftime("%Y-%m-%d")}
  :PROPERTIES:
  :EMAIL: #{email}
  :PHONE:
  :BIRTHDAY:
  :CONTACTED: #{Date.today.strftime("%Y-%m-%d")}
  :END:

TEMPLATE

File.open(contacts_file, "a") { |f| f.write org_template}