I was asked to come talk to second-year IT programming students. I wasn’t quite sure how I would approach it, and it wasn’t until the other panelist, a recent grad from the college, started telling their story about the cool things they’re doing in IT operations, that I really started to gel on what I wanted to talk about and how I wanted to frame things. And it does come down to taking an attitude of service and craftsmanship to the job. And here’s what I told them.

I have hired 100-plus people in my career, and I’ve interviewed probably north of 500. And a lot of the people that I’ve hired for have been in entry-level positions. I use credentials as a weeding exercise to get to a pile I can read. Because in certain seasons, especially for term positions, I would get hundreds of applications.

But when I do a detailed read of the resumes and the cover letters, I actually look at the adjacent experience. For example, if you’re early in your career and you spent five years in Army cadets, then I already know a bunch of things about that individual, or that they’ve done a bunch of volunteer experience, or that they’ve worked in retail. Working in retail tells you a lot about their ability to provide customer service and work with people. Because there’s no such thing as a technology sector. Every sector is a technology sector. And you will inevitably pair up your IT skills with a business or domain skill set.

I know every student who’s about to enter the workforce, and particularly those in development fields, all of them have the exact same question. Is AI eating entry-level jobs? Am I fighting robots?

Maybe it’s true in this moment because the technology is new and people are still learning how to actually make things work. And yes, displacement happens as it always happens when technology comes along. But it always brings with it opportunity. And even in the AI era, it does. So, is AI going to eat entry-level jobs? Not really. AI has just changed what an entry-level job looks like.

I use AI every day in my work and in my personal pursuits. I use AI to help me plan so that I can create stuff. I build stuff and I experiment. And this is what it looks like.

I recently had to build a Power Platform solution. I don’t know Power Automate very well at all. I mean, I build all kinds of other things with SharePoint and such, but I mean, Power Automate, what the hell is this? Well, it’s the tool I had to use because it had to live in the Microsoft ecosystem tied to the Microsoft Graph and in a trusted secure framework. I didn’t want to just try and get Copilot to build it for me. Because I’ve known from past experiences that it was really important that I understand the code and what I built. So that if it came down to trying to troubleshoot it later, or if I had to hand it off to someone else, they could figure it out. I wanted to make sure that it was well documented, and that I actually understood what was going on. To that end, I deliberately resisted getting Copilot to build the damned thing for me, and rather used Claude as essentially a talking book or talking manual.

I built it by hand, following the recipes from the spec document that Claude helped me with. And every time I ran into a problem, I’d have to take a screenshot, toss it over there, and then say, “Hey, Claude, this ain’t working.” And that felt like a genuine way to build something that’s somewhere between vibe coding and actual coding. Because you’re actually doing it yourself, with a wizard on the shoulder to try and help.

I don’t think about vibe coding pejoratively. I mean, vibe coding is an approach. At least when it’s done right, you start with what you want the user experience to be and what you want the outputs to look like. You talk through all of those things first, and you come out with an outcomes-based specification document. And then you let the agent cook. Just make sure you do the planning and specification up front to as much detail as possible. That’s key. Vague intents and goals beget sloppy results.

Now, because I come from a developer and IT background, I was able to produce solutions that were genuinely useful. I know what good looks like and it makes all of the difference in the quality of the code I build and the quality of the solutions I ship. Learning real skills does make a difference, even in this age of AI.

In the context of working in the technology trades, you really only have to worry about a couple of things. Did you do good, honest work with a sense of craft and quality? Or did you just rush through and bang it out and get it done? And of course, you always have to ask the question whether or not you’ve added value and helped people.

I’m not going to pretend that I’ve had a perfect career. I screw up often. Sometimes it’s embarrassing, and sometimes it’s just plain funny. It depends upon the stakes. A couple stories:

GroupWise was an interesting enterprise mail system that was made by Novell before Microsoft Exchange had its stranglehold on the market. It is a horrible feeling to be two in the morning sitting in a server room with a broken set of mail servers and you don’t really know how to get it back together again. Because you didn’t write the assembly instructions down the first time when you built the thing. When you’re tired, and you have to go and reconstruct your thinking from a year ago from scratch, it’s pretty close the dumbest thing I have ever done. Now I generally build specification documents and document as I go and maintain a build log for nearly everything I do that counts.

One evening a few years ago, my boss and I were trading emails about a flaky reporting system someone in the business had built. And it was a mixture of different enterprise technologies and a reporting engine running on a machine with a sticky note that said, don’t turn off.

Classic, did I click reply or did I click reply all?

Anyway, you know how that went. I thought it was an email direct to my boss. But it was an email direct to my boss that had the client, the solution owner, on the email. And I had called the person’s thing that they had worked on for many, many years. Their baby. A contraption. I had to go meet with a person, buy them a coffee, and apologize. The relationship did get better, but it did require me to own my mistake with a certain amount of humility. One of the things you’ll have to learn is the art of apologizing in a professional context. No small skill.

Okay, enough war stories. What students were looking for is how not to step on rakes.

Early in my IT career, I spent way too much time working and driving forward. I missed time with my family, my other interests, and stuff like that. And you don’t get that time back. Nobody rewards that kind of effort. They reward the results. If you find you’re in a job where you’re working sixty hours a week on the regular, then it’s possibly time to change jobs. Of course, I’m a big old hypocrite. I did the preparation for the student panel session, and I’m writing this blog post while I’m on vacation. So in classic dad fashion, do as I say, not as I do.

End of the day, you don’t have to take work personally. I mean, yes, you do have to take it seriously, but you don’t have to take it personally. And you don’t have to have your ego on the line all the time. One of my rules of work is “don’t be a hero, heroes die.” I’ve observed in people, across my career, that the IT ego is real. The sense that you are the sage, you are the one that has to have the answers. One of the students asked about imposter syndrome, about how it felt like they were faking it all the time.

Which I totally get. I might not have all of the answers, but I have an IT lens and an IT predilection towards understanding things, an IT view of the world. But I know I can help fill in the gaps. My perspective matters. And so does yours, because it’s different and reflects what you’ve learned and experienced. That’s how you can help. When that is your approach, you don’t have to worry about imposter syndrome so much.

I usually participate in these panel sessions in front of students a couple times a year. And very often, I don’t get a lot of feedback from the room. And that’s fine. I just hope there was a nugget that they could take away.

As always, I put the offer out there for students or anyone at any stage of their career. If they want to chat with somebody who’s been through the wringer a couple times, I’m always available and willing to chat. Willing to coach, willing to listen. Send me your resume and I’ll give you some pointers. Just reach out. LinkedIn.

It’s how I can help.

I was talking with a colleague today, and we were swapping stories about drowning in email. About how you would go through an inbox and mark something as flagged or mark it unread, and then everything would be a sea of flags. Of course, you still wouldn’t read everything, and just get overwhelmed, because there’d be no way of sorting or prioritizing any of it. Very often what happens is you’ll declare email bankruptcy, select all your flagged and unread email, clear the flag and mark ‘em all read. Archive everything to hide your shame. Not exactly an effective strategy.

That got me thinking about my setup and what I was experiencing before I sorted out the email triage thing. I avoid message flagging as much as I possibly can because I know that I won’t ever clear the flag.

I get a lot of email and I’ve been toying with different Outlook rules over the years to help with the triage. One of my favorite Microsofties, Scott Hanselman, wrote a blog post almost a decade ago talking about taming the Outlook firehose. And one of his big rules was to automatically move email that you’re CC’d on to another folder and get it out of your inbox. The TO field is for action, the CC field is not.

Things went to hell when Classic Outlook got the boot and New Outlook hit the scene. Classic Outlook had a lot more mechanics and things you could do with rules. People built quite the contraption of rules with the old MAPI client. I was one of those people.

I prefer the New Outlook because I find it faster and search works better. While it doesn’t have feature parity with Classic, for all the things I care about, it is a superior experience.

One of the things I’ve learned over the years is that filing email into folders was never going to be the answer, because stuff generally belongs in more than one folder. Best of luck which folder choice won the pick-decision three months ago.

In short, bucketing the email by its content doesn’t work. Setting up email rules based on its send/receive profile does.

So, I’ll run you through my rules, top to bottom. The order matters.

First and foremost, you got to go and deal with your meeting invitations and stuff like that. One of the things I like to do is actually just to make a category called Invite and tag incoming mail based on its item type. You can make a search folder that looks for the category and pin that to your Favorites in the sidebar.

The next rule that you make is the Big Override. There’s usually a bunch of folks in your orbit. Your peeps who work directly for you. Colleagues who are your direct peers. Managers and leaders up the chain from you. And your direct manager’s peers. This is what amounts to being your Circle of Trust, if you will. Create a rule that sets the category. Call it whatever. I use Circle.

Your next rule will be to tag all of the emails that you know are actionable. You can’t always count on them being actionable by sender, but you can usually bank on the subject line. Give these a tag called Action. You’ll probably want to make exceptions depending on your sitch. So those are the categorization rules.

The next set of rules are going to be around moving email into folders. Pay attention to the categories above. You’ll see why I bothered.

So the next rule we’re talking about here is to deal with the alerts. And this rule basically says: if the email is from these senders, move them to a folder you create called Alerts. Add an exception, if it’s categorized Action. This moves application-generated noise to a folder out of your inbox except for the stuff that you actually need to do something with.

The very next rule is the money one. It will be to deal with the email that you’re only copied on. The rule moves the message to the Copied folder unless the message is a member of your Circle. That’s it. It shuffles a bunch of stuff that you’re not on the TO field out of your inbox unless it happens to be from one of your peeps.

The next rule is one to move all of the friendly low-priority bulk mail out of your inbox. And it’s really simple. If the sender contains your email domain, it’s internal email. And then you’ll pick the distribution lists or anything that’s common to their distribution lists. One element that’s common to ours is a hashtag symbol at the start of the recipient address. Make an exception for the Circle, and send everything else to a Bulk folder. I think of this as my “ham” folder, the more palatable cousin of “spam”.

The last rule in this sequence is optional. You might not need or even want this. In my role, about two thirds of my email is internally generated so I use this one, but you don’t have to. Essentially, if the sender’s address contains an @ symbol, move the message to a folder called External. Except if the sender’s address contains nscc.ca (internal). Plain and simple.

Those are my rules in a nutshell that gets the job done. The workflow looks like this:

• I have a couple search folders. One that shows Invites. One that shows my Action items. I mark them as favorites in Outlook so when I glance, I can see when I get a new meeting invite or when there’s something that requires action from me.
• My inbox is only email from internal folk that is sent directly to me or from senders I prioritize. I think of my inbox as important people trying to get a hold of me directly. I keep a close eye on this folder.
• I’ll look at the External folder often as well as these are often email that’s sent directly to me. But it’s from vendors or from partners or from other external folks that I actually care about the relationship.
• The Alerts folder is full of stuff that machines want me to pay attention to, not people. I rummage there only when I’m looking for something in particular.
• I check the Copied folder about once a day, because if I’m copied on something, it’s informational only and not for me to respond with any urgency.
• If somebody has CC’d me on an email expecting me to respond right away, they’ve misused the tool. I will subtly correct them if they ask. It’s perfectly fine to subtly coach people with how you prefer to be communicated. Outlook makes it dead-easy by putting @mentions on the TO field automagically.
• Maybe every couple of days, I’ll look at the Bulk folder and enjoy all the kittens-for-sale emails, the cafeteria menu updates, and their ilk.

Of course, the real hack is to not have your Outlook open all the time anyway, and only open it a couple times a day. These rules all run in the cloud so you don’t have to babysit your inbox.

And to be real with y’all, and I’ve said this before, very few job descriptions list being a superstar with email as a critical job duty. You were probably hired to do some other human stuff.

Good rules is good defense. Now, get back to work.

My algorithm feeds are chock full of AI junk that falls in two camps:

1. The Anti-AI Army who hate this stuff and grasp on to any and every reason to reject the technology, even if that means siding with conspiracy theorists and fallacious argument. There’s truth in a lot of it, but there’s also a lot of crackpot BS.
2. The AI-pilled who seem to want to foist this tech on everyone else, citing its inevitability as the reason to be first. The premise is somewhere between suspect and false and it’s sending folks down garden paths and dangerous places.

And then there are the pragmatists. They see the potential value of the tools, hate the industry and its weird-ass philosophies, but… don’t want to be left behind in an economy that’s shifting.

Somewhere in there is a group of people who want to do the whole Tiago Forte “second brain” thing with Obsidian, but do not want to commit to a subscription tool like Claude Code or OpenAI Codex or anything like that. They want something a little more free-ish. The good news is I think these folks could get away with using OpenCode and its free model toolkit pointed at Obsidian. You can get most of the way there without spending a dime.

I make no bones about fan-girling over Obsidian and Markdown as a note-taking app and durable file format. I wrote about this a couple weeks ago. But the short version is that you point the app (Obsidian) at a folder on your computer that has your notes in human-readable formatted (Markdown) plain text files. Okay, great, we have a folder full of plain text notes, but what do you do with it when you want to use AI with these files?

So, this is what we’re doing. We are going to point the robots at your notes. Specifically we’re talking about OpenCode.

You can think of OpenCode as like an open source alternative to Claude Cowork/Code or ChatGPT Work/Codex. There’s a desktop app and then there’s a terminal application. You can use whatever makes sense for you. You’ll get similar results. The big difference between what you see in OpenCode versus the Big Boys is the model choice. For example, with Claude, you’re basically tied to Anthropic’s models. With OpenCode, you can use any number of model providers. Sure, Claude might be a more mature tool, but to be honest, OpenCode is more than adequate for nearly every one of my use cases.

OpenCode pays the bills with paid services Zen and Go. The models offered are vetted to work well with OpenCode and is price competitive.

If you really don’t want to spend a dime, the OpenCode project includes a handful of free Zen models they make available without a subscription.

I’ve tried and tested a slew of the other free-ish offerings and I won’t bore you with the sad journey, but haven’t found anything better. I even tried hosting a local model on my own hardware, but my computer isn’t beefy enough to do such, and the price of hardware these days makes it cost prohibitive. I have better things to spend $5,000 on.

The biggest complaint and objection about using free models is that they collect some of your data, your inputs and your outputs, and send them back to the mothership to train future models or to do future post-training.

The whole idea of worrying about your outputs and inputs being used for training data is the wrong lens. You can choose what context you give it. If you are giving the AI personal information, your hopes and dreams and stuff like that, then maybe you should think about that. You should think about your social media use too, for the same reason. Jussayin. I find it so weird that folks are wigged out about their AI chats being used for product improvement while feeding the TikTok and Insta algorithms like a bunch of apple-drunk squirrels on an acorn bender.

Use the tools, but treat them like postcards. I wouldn’t put anything there that you wouldn’t want to be used to embarrass you somewhere in the future. The risk isn’t training data. It never was. The likelihood that the next-token predictor is going to spit out a string of an individual’s personal deets has always been implausibly small. It’s non-zero, but it’s not the risk I’d lose sleep over.

The real risk is when you give these things unrestricted access to your computer. That’s the threat vector.

That and your work data. And personally identifiable information. Follow your employer’s AI usage and data handling policies.

Where were we? Right. Point the robots at your notes.

So, you finish getting your Obsidian vault set up, and you make that first file: your about-me file: how you think, what you do, what is important to you and what isn’t, how you work, what good looks like. Don’t get fancy. Bullets are fine. Dictating a ramble into the file is also fine.

Then go to the OpenCode website and download the app. There’s instructions for Windows or Mac or Linux or whatever you happen to be using. I like the Terminal app, but the Desktop app is great too. Six of one, half dozen the other.

When you fire it up, point OpenCode only at the folder where you have your Obsidian notes. If you’re feeling extra cautious, make an AI-only folder inside Obsidian and point the OpenCode agent at it. It’s best practice even once you get more miles under your belt and know what you’re doing.

It will ask you if it needs to traverse outside of that folder before it does anything else. If you say yes, it can definitely run low-level commands for you without asking again (that’s the point). And all of those shell commands can do pretty dangerous things. There’s caps on the scissors most of the time, but you can take them off and then go running gleefully and delete all your precious notes. So maybe make a backup once in a while. You do backups right?

Once you have an agent chat session open pointed at that directory, you’re actually good to start. The default model is the free OpenCode Zen model: Big Pickle. If you’re in a rush go ahead and configure a provider and pick a model with the opencode /connect and /models commands.

We’ll come back to models in a bit.

Your first prompt in OpenCode in your Obsidian vault should look something like this:

You're in an Obsidian Vault. read the about-me file to get started. Your goal is to setup Obsidian as a space for both the human and the agent to work together. Interview the user with smart one at a time questions, starting with the biggest decisions first. The user's answers will direct your questioning, but remain on task. If you are unsure, ask the user. Do not make assumptions and push back as needed. When you are 100% confident you have a full understanding of the requirements, present the plan to the user. The user approves the final plan before you implement.

The agent will ask you some questions about who you are and how you’d like to work if you haven’t answered them already. And then it will propose the structure. And you can tweak it. And you can go edit the files yourself, because they’re just your text files. You can see everything.

There are a gazillion frameworks for this, and you can watch 17,000 YouTube videos about how to set up a Second Brain in Obsidian. Don’t fall for the trap. None of it really matters. None of the systems on YouTube are your system. The takeaway idea is: don’t try and build this yourself. This is good work for a robot to do.

Now, about models.

One way to think about it is the model is an engine of a car and the harness is the steering wheel, the transmission, the drivetrain, the body. An engine by itself doesn’t do much. You have to put it in something for it to do anything useful. And hopefully the human is driving the goddamn thing with enough coffee on board to keep it between the mustard and the mayo.

• ChatGPT is the harness. GPT-5.6 is the model.
• Claude Code is the harness. Sonnet 5.5 is the model.
• OpenCode is the harness. Big Pickle is the default model.

Despite the name “code” peppered on all these products, I actually do precious little coding. Most of my AI time is working with documents, data and content. And it’s become very clear that, over the last year especially, the model choice has very little to do with the quality of the output.

“New & Improved” doesn’t mean the previous model is “Old & Inadequate”.

It’s not the models that do the fancy stuff anyway, it’s the harness itself that takes action. Your skill in using them matters. You’d be surprised how far you can get if you slow down and stop treating these things like magic black boxes where you say: “Create this awesome thing. Make no mistakes.”

What makes a harness better? If it has a model that does reasoning, can search the web, and a way to manage the context window.

Context window?

No worries. I got you.

So a context window is essentially how much of the conversation, both the input and the output and the thinking, that the model can keep in its head via the harness at any given time. Bigger is better but only to a point. Some models have a million token context window, but in practical terms you can only use half of it before it starts forgetting stuff in the middle. Don’t get sucked into the spec bullshit because what’s advertised ain’t always reality. The heuristic that I find useful is to keep it under 500K for a million token model. And when you only have a 200K model, keep it to 100. Anything after that, it starts to get mushy.

All the newer harnesses can show you a percentage of the context window in use.

The fact that they can save the keeper outputs to a file to reuse as inputs helps dramatically. This is what makes these agent tools better than pure chatbots.

I continue to be really surprised at how well the lesser known models perform. Even the slate of free models in OpenCode are fine for almost all of the work you’re doing. If you’re getting it to read an article and summarize it for you, or getting it to edit notes you made in Obsidian, Big Pickle is good. You don’t need a chainsaw to carve a roast.

Now, if you want it to write for you based on an outline you developed with a free model, then you might want a better model. But you probably shouldn’t. Get the model to help you build the outline. Help you test the facts and check the web, search for things, verify what’s going on, do all of that skeleton work. And then once you have a good skeleton, go write the damn thing yourself based on the prep.

At least then it’s better work, in your words, and the Anti-AI Army might leave you alone.

I’m running a Mac without administrative rights, and when installing Augure Desktop, I was prompted to install a CUA (a Computer Use Assistant thingy) that required elevation. So I had to dig in. Actually, I had the agent itself dig in and troubleshoot itself, because I ain’t got time for that shit. And it was quickly revealed that this was essentially a modified Hermes. I was expecting a Claude Cowork situation and got much more. I was taken aback.

Which is fine. No notes. Leveraging an existing open-source project is the right call for the Augure folks to make. It took some finagling to get the CUA working in userspace without giving up the farm, and as it is now, I’ve configured pretty strict read-only permissions on the minimum, but there’s a lot of knobs and dials. Augure’s command line tool is a command line tool, and the mobile tools are like every other chatbot.

For the last year or so, all of the dialogue has been around what came after chatbots, because we had chatbots for the first little while, and they did things. Then, about a year ago, we got into this whole coding harness framework thing (Claude Code, Claude Cowork, Codex, et al) where we figured out that these LLMs were actually good at coding and stuff. So we built harnesses around them so that way they would have memory and they could follow the plot and they could actually build and accumulate knowledge. The whole “second brain” gamut.

It was really good for knowledge work rather than just going and using a chat thread that had a finite context window. A coding harness in particular could keep notes as it went along. You could actually have a much longer conversation because you weren’t trying to keep everything inside the chat thread itself. The agent, which is what you would talk about at this point as opposed to being a chatbot, would just keep checking the notes and refreshing itself and modifying accordingly. And that’s where this whole idea of a God thread comes from: one thread to rule them all. Whereas in the old chatbot era, we had to save the context and reload a fresh chat to continue going. We would always end up having to start new chats all the time. But now with these coding harnesses, and the ones that are more tied to the productivity space, like Claude Cowork, we get this new thing: persistent context.

And now there’s this other twist. Just a few months ago, we had this whole Clawdbot thing that eventually became OpenClaw and now Hermes is a thing: people are setting up these essentially coding harnesses and agents in a way to run them 24/7. They set up a MEMORY.md file to keep notes with itself, a USER.md about the human, and a SOUL.md about how the agent would behave. And then, of course, there would be the AGENTS.md, which governs its actual rules. People now can run semi-autonomously so they started giving them access to their other digital tools that impact “meat space”. And that’s when shit started getting scary. Running with scissors stuff.

Anyway. Where were we? Right: Augure.

So when I first looked at Augure, it was essentially as a Canadian replacement for what I was using Claude Code and Cowork for (a web tool as well).

The TL;DR is that it’s a Canadian-hosted version of some post-trained models (probably Llama), at least the Tofino and Ossington ones are. The new Rosedale One is based on GLM 5. The post-training is about multilingual stuff as well as Canadian legal standards and all that jazz. The attractiveness for me is that it’s sovereign.

And now, as of last week, we have this brand new consumer-facing thing from the mad engineers at Meta: Muse.

What’s exciting about Muse is that it’s actually a significant departure that none of the other big players are doing. Google AI Mode and Gemini don’t do this. ChatGPT doesn’t do this. And nothing in the Claude stack does this. But essentially, Meta, has been the first “big boy” to market with a consumer-facing 24/7, always-on personal assistant agent.

Grok Bot is a thing too, but we don’t talk about Grok here.

Anyway, Muse is not a chatbot. It looks like a chatbot, but it is not. It is a 24/7 agent that can act in this world (well, with whatever you give it, anyway). I’ve been playing with Muse for the last few days and lo-and-behold, it’s also just Hermes underneath.

Which means we can compare things.

Augure’s desktop tool is like flying a helicopter. There’s a lot of controls exposed to you, and the learning curve is fairly steep. It’s a power user toolkit. Most normies will have to rely on the mobile tools or the website to get a more expected chatbot experience. Augure Desktop is not the same as Claude Cowork. Straight up.

But Meta’s Muse by contrast, is so damned friendly and polished and clean that you would never know that behind the scenes it is extremely complex. It’s friendly enough that your boomer gramma could use it. No joke. However, in order for Muse to be truly useful, you have to give it everything: the more access you give it, the better the tool responds. It’s very much like a personal assistant. Meta gives you a cute little avatar you can customize and make your buddy, and you can wire it up to your mail, your calendar, your bank account. Don’t do that. It can act as if it was you in the real world. That’s genuinely useful, so long as you trust Meta to take care of your data. To Facebook’s entrepreneurial credit, I can see how Muse can be ridiculously addictive. It’s actually their best product in years, if the goal is to hook all your users on the new drug of choice.

And like Cal Newport says: these models aren’t really that good, or haven’t really improved that much in the last couple of years. They’ve made incremental improvements. The hype is off the charts. But what has changed in the last year or so in particular is the harnesses that are built around them have matured greatly, which is why we’re seeing these agentic OS contraptions bubbling up.

It’s been a really weird summer: all kinds of AI breakout events getting highly publicized, both for the benefit of AI companies looking for IPOs and also to stoke the flames of the doomers. I don’t know what the average P-doom is, but here we are. The conversation around AI safety is starting to increase, but this AI safety stuff is really very much talking about how things are trained and how they’re being used at scale. But no one’s really talking as much about the other side of AI safety, like we talked about a year ago, people using AI in the Joaquin Phoenix kind of way and pathologically addicted to it. There are real social harms to using these tools all the time, making it a weird time for Facebook to release Muse.

I get the push to move towards these more immersive agentic tools, everybody trying to find a way to monetize and come up with an actual product that people want. And let me be clear, no one actually was asking for this stuff.

For the most part, tools like Claude Code and Codex and stuff like that, the only real killer feature is actually in the programming and code development. All of the other stuff around knowledge work is YMMV territory.

I certainly get a lot of value from a knowledge work perspective, being able to use the tools as a research assist and as a way to structure and edit my own work, though I spend quite a bit of hand-wringing and navel-gazing over what authorship looks like when AI tools are involved. I think I’m getting it figured out.

As a raw productivity tool, it’s normal technology.

But when you look at stuff like Muse, this isn’t normal. This is something else.

It’s pretty muddy. Some is political, some is ethical. We all have our lines. I tend to take a managed-risk approach, the whole shadow-profile thing, but I really don’t like the trite line that “people who have nothing to hide, hide nothing.” And yes, it’s about data brokering to advertising firms and other sentiment analysis, but criminal activity is real too: what’s leaked can be used for spear-phishing, catfishing, pig-butchering, even straight-up fraud.

Maybe the approach is to only trust the big guys, since they have security and IT departments bigger than most companies. It’s kind of a gross feeling and I just threw up in my mouth a little bit, but sometimes too big to screw up is enough of a motivator. So who do I trust to protect my data more: Facebook or MyFitnessPal? Neither is the right answer. But knife to the throat, I probably trust Facebook and Google more than the smaller outfits.

There’s no tidy answer or helpful “Doug recommends X” here. It’s just that folks should educate themselves, follow the money, and manage their risk. Also trust your gut: if you don’t trust Facebook to purchase stuff on your behalf, don’t give them your credit card. However, if you’re already in the Google Fitbit / Apple Watch ecosystem, what difference does it make that you give your fitness data to Meta Muse so your friendly little buddy can coach you along, and creep your wall, and silently judge your food pics on Insta.

All that said, I’m still going to use and continue to experiment with Augure because for my real work, thinking in sovereign terms is very compelling to me. But at the same time, I’m going to continue to play with Muse because it is a novel Bright Shiny Object (BSO) and my brain won’t let me ignore it. It is indeed interesting and something that I think that a lot of people are going to pick up and not think twice about what they’re actually doing.

The story goes that I had to go to Sobeys the other evening but I had to put the farm animals away first. I usually have the dogs with me so it’s often a one-handed affair. That evening, I collected one egg and put it in my shorts pocket. I finished, brought the dogs inside and headed to the store.

It wasn’t until I happened to bump into something at the store that I realized the egg in my pocket was still there and now broken. I knew exactly what it was as soon as I sensed the wetness, and I immediately regretted a few recent life decisions.

I made tracks through the aisles picking up the items I needed and by the time I got to the cashier, I was walking like an old man who’d shit his pants. Rhonda works at Sobeys so I happen to know many of the cashiers and they know me. The one in front of me asked how I was. I blurted out that I’d be better if I didn’t have a broken egg in my pocket. She offered me some paper towel but I declined, saying that what was there was contained and it would become considerably worse if I tried to scoop it out.

So I went home, asked Rhonda if she minded if I took a bath first. She asked why. I showed her. She howled with laughter. I scooped out the egg ruins and rinsed out my shorts, and underwear, and socks. She promptly told everyone who’d listen to the tale. Can’t say I blame her. I’d make hay off that sitch too. This evening, I again collected eggs prior to going to the store. Of course, she asked me to check my pockets. Can’t say I blame her for that either.

Okay, sure, that’s a funny story. I can’t deny it. I have to admit though that this isn’t the first forgotten egg smashed to goop in my pockets, and it’ll doubtlessly be the last. It’s part of the absent-minded-professor affect, I guess, but that’s also a cheap cop-out. It’s likely useful to explore why I did this, and continue to do this. And because I underthink some things and overthink others, this is as good a topic as any.

So I have to ask why this happened, right? Was I distracted with too many things going on in my head? Was I too busy thinking about the next thing I was doing to pay more attention to than the thing I was doing? Probably. So the real question is: what was I thinking when I was closing up the farm and driving to the store and doing the shopping and promptly forgetting about the egg? It’s been a busy few weeks. There’s been a lot going on. September startup at the College is a busy time of year. I was working on some major projects that had to be done. And if we want to get specific about what this time of year means to me: the zucchinis getting too big, running out of time on when to pick what, and what to do with everything. I still haven’t gotten to fixing the goat fence, it’s just patched. And the attendance tracking project at work is an ongoing series of bug fixes and tweaks, which is 100% expected but always more involved than you plan. In all of it, when I’m tired, this is soup in my mind. It’s a medley of images, where I flip from one scenario to another scenario to another scenario, trying to keep all of the balls in the air and keep all of the vectors pointed in the right direction, if you know what I mean.

There are many kinds of soup. There’s soup at work, there’s soup at the farm, there’s soup all over my place. Wherever you look, it’s soup, soup, soup. And sometimes you don’t even have what you need to make soup. Sometimes all you have is chicken shit. And you’re forced to make chicken soup out of it. And sometimes it’s chicken shit soup.

This kind of thing happens to me all the time, especially in meetings. I find it hard to follow and stay focused when there are many voices. I end up thinking about what happens next. Often a thread of what is being discussed sends my brain chasing rabbits because the seed of thought had to be pursued, so I lose track of the main conversation. This happened yesterday in a meeting and I’ll stay generic to protect the innocent. I was lost in thought and snapped back when someone asked me a direct question. It took me a moment to reorient and thankfully I was still in the game, but I haven’t always been. I’ve been caught and called out. S’fine. It happens.

My main tactic to make sure I don’t hyperfocus on one part of the conversation and miss the rest is to actually mildly multitask, just enough cognitive stimulus to prevent me from bounding after bunnies but not so much that I get immersed in another task. Checking email? Nope, don’t do that, that’s a very bad multitasking focusing partner. For me, taking notes is almost as bad, which is why I love meeting transcription. It’s the cat’s ass, the bee’s knees, and the elephant’s elbows. AI recaps of transcripts are useful, and being able to trust that you have the transcript to derive notes is often enough to stay present in meetings. But sometimes I have to doodle, or do a sudoku or crossword, or even on some meetings, put some ambient YouTube video in a side window. Sometimes it’s just dropping questions in Notepad for later that I can add to the transcript to focus the notes with AI later. Just enough secondary activity to keep me focused.

My very ADHD wife knits while watching a YouTube picture-in-picture while playing some clicker game on the phone. The TV may or may not be on. I can’t do that, but I get the impulse that drives it.

There are many things for this. Some people fidget, some count in their heads. It isn’t always or even often about interpersonal interaction, it’s anything. Why do people play music while working? It’s a cognitive ballast tool. Flow states and all that jazz. Thankee sai, Mikhail Csikszentmihalyi.

Check your pockets.

I have always preferred plain text.

Back in the early 90s, I used BBSs all the time, so I was pretty used to writing and reading in plain text, long before Markdown had the formal conventions for structuring text and adding styling. I adopted what was there already, the asterisks to indicate italics, stuff like that. Anybody can do this now.

Early in my IT career, I always felt stuck and trapped in an application’s ecosystem. WordPerfect was the darling-doe for a spell and three or four years felt like forever at the time. But I knew in my heart of hearts that it was a house of cards.

File format choice is almost as important as the argument people make for physical books: what happens if all the computers die? Well, what happens when the paper rots? I’d take plain text markdown and printed media as almost two sides of the same coin. It’s about true ownership over what matters.

As it turns out, plain text markdown is the preferred format for agent ingestion. But even if AI didn’t exist, even if this kind of ingestion wasn’t important, plain text has always been what’s going to save my arse and make sure I survive the app apocalypse.

You throw a Word document into Claude and it’s got to convert it to markdown before it can do anything. If your content is already sitting in markdown, it burns fewer tokens getting the job done. At some point we’re going to care a lot more about the inference cost of our tools once the AI companies stop sponsoring everybody’s habit formation.

Here’s a good way to think about it. You can consider plain text and markdown as true editable “source code” for your content, and then you “compile” the markdown document into a format like Microsoft Word, PowerPoint, PDF, even an EPUB. Whatever.

Okay. So you basically have file folders, and in those file folders, you have text files conforming to some sort of naming convention. What you really need is a way to browse the files and work with them.

There’s two big contenders that come to mind. One of which is Obsidian, and the other one is VS Code. Both have the same kind of paradigm. On the left, they have a tree view to navigate your files and folders, and then on the right-hand side, you open one or more files in editing panes. VS Code is geared for coding and Obsidian is more about note-taking. It’s a matter of taste and both are free. Obsidian happens to be Canadian, if that matters to you, and it makes markdown-formatted files more presentable, so it doesn’t feel like you’re sitting there as Hackerman.

Obsidian works everywhere. Install it. Right now. I’ll wait. Good. When you open it up, it’s going to ask you to create a vault, or open a folder as a vault. You can point it at any file folder that’s on your system.

If you’re the kind who needs something that syncs your files around, like OneDrive or Dropbox or even iCloud Drive, you can store the Obsidian vault in any of those locations. Go for it. Make a dedicated folder for this and only open your vault on one device at a time, you monster.

If you’re using an iPhone and you happen to have a Mac, just go ahead and use iCloud. Set it up on the phone first and it just works. If you want to sync to your Android or Windows, there are a couple free options that work with OneDrive and Dropbox. If you’re keen to support the developers and pay for their Obsidian Sync service, it works on everything without any fuss for four bucks a month.

Don’t make the same mistake everyone makes with paper journals and pre-organize yourself to death. Just create new files as they come up. You can always organize them later, because they’re just text files. Create folders only when you need to create a folder.

Obsidian has a kitchen sink full of doodads and whatsits. If you want the minimum, so that you’re not getting distracted, stick with the default theme and the core plugins and don’t get fancy.

But if you’re going to use the Daily Note plugin, you might want to use Liam Cain’s Calendar plugin from the community. That’s it though. Stop fiddling with it.

If you’re looking for an idea of what file to create first, create yourself an about-me file, a file that you would put all of the information about yourself in, how you like to work, how you like to think, and how you like to see things formatted. Put in what’s important to you, what’s not important to you, your priorities. Just a bit of a brain dump. Organize it in bullets if you must.

Because: at some point you might want to point an agent at your vault like Claude Code / Cowork or ChatGPT Work / Codex or whatever is in vogue next month. This is the whole “second brain” thing. One of the first things that it will need is the context about you. Even if you just refer to it yourself, it’s a way of grounding. You get to say: hey, this is the space, this is what it’s for, and this is who I am, and this is what I expect.

After your about-me file, your next best choice is the daily note. Just click the daily note button and it opens up a note with today’s date on it. Dump whatever’s on your mind any way you like. I like to dictate this on my phone. That’s my jam.

You can organize your notes in folders if you like, or tag them in the properties, or use the built-in linking like Wikipedia. Or nothing or all of it. Just resist building the structure ahead of time. Trust me.

Who is this for? Well, anybody. If you work with a bunch of text, and you want to break away from Word to write. Maybe you just want your notes to be AI-ready or at least future-proof. Your ideas don’t have to be rough any more than they have to be polished darlings. You can write in bullet points or prose or mix and match. It doesn’t matter, because when it comes to working in plain text, you’re not worried so much about the formatting. You’re focused on the words themselves and the story you’re telling.

A couple days ago I noticed the fence I built for the goats bowing out near the house. Peanut, the boer goat, had been rubbing on that corner, the one closest to the humans. Went out today to patch it and she’d pretty much destroyed it. Welded wire snapped off in spaces. Now I’m ripping out a couple panels and rewiring them, and I think I’m putting a rail about sixteen inches off the ground the whole way around, maybe higher, so when she shoulders into it she can’t rip it apart anymore.

I spent a lot of time and a lot of energy and a lot of procrastination putting that fence together. Finally got the goats out there, and they’re enjoying it. But as the old adage goes: if it won’t hold water, it won’t hold a goat. That’s where we’re at.

That’s probably my mood in a nutshell. It’s a metaphor for what’s going on with the US and Canada and trade right now. Elbows up and all that junket. It’s a metaphor for foreign wars. It’s a metaphor for the frustration of work that seems pointless sometimes.

Faculty are coming back to their organizations that have had some changes over the last year, restructuring and such, unsure how to actually deal with AI in the classroom. They know it’s not going anywhere, it’s not a fad, it’s something they need to adapt to. Some are just wondering what tool they’re even allowed to use, because AI policy lags behind the pace of the tech. Returning students are tired, working, busy, trying to do all the things. New students are just trying to figure out what the hell they wanna do with their life. Times are tough. They want a good job, some value for their money, to make something of their lives without having to suffer, which is what this world feels like right now.

There are things you can change in this world and things you can’t. You can’t control the machinations of a foreign power. You can’t change the fact that the world is on fire. But you can change the things you control. You can make sure you do good work. You can make sure you’re kind to other people. You can make sure you’re in service to other people, actually helpful in this world, a good citizen. You can make sure you’re kind to yourself. And tongue firmly planted in cheek, you can realize none of this effing matters. It’s all just a point in time, and this too shall pass is a pretty reasonable way to live. Nothing is forever, nothing truly matters in a long game. All you’ve got to do is make sure you’re doing right by your own values, and that you’re honest with yourself.

That happens on a regular basis for me. It happened back in the spring, during the organizational changes related to our reduction in force. A lot of uncertainty, both in my own employment, though I was ultimately fine, and in the employment of others. It’s bled through the rest of the year, people leaving their roles for greener pastures. The work didn’t go anywhere. There’s been a lot of churn, focus, activity, trying to make sure the organization can operate without key people that were in place. These things happen. You don’t always get it right. I even had my own scope of work change. It can be overwhelming, and I do have to tell myself, quite regularly, and it is helpful: Doug, you can only do what you can do. Prioritize the right things, be in service of the learner and the organization, and you’ll be fine. As long as your priorities are in the right space, and you realize that, none of it really matters. You are a cog, but you can be a useful cog that does good useful things. I make sure I’m kind to other people as much as I can, and I make sure I stay human, because that really matters more than anything else. That’s what it is to be a real person. So I remind myself, when I get overwhelmed and angry at the machinery of the organization: none of this is anybody’s fault. No one’s out to get me. It’s about bringing craft to the job. I’ve talked about craft before as a sense in how to make things, but it can also be an approach to living your life.

We lost a colleague recently. Someone I knew and worked with. Since COVID happened I kind of lost track of him. It is hard to stay connected to people. He’s not the only one. I lost another colleague about three years ago, someone I was great friends with, who got cancer and died. And now we don’t have these people in our lives anymore.

Part of being a person in my mid-fifties is watching people disappear, either they move on to other careers, other jobs, or they pass on to the other realm. The reduction in force back in the spring came with its own grieving process too. Because we did lose people. The stuff they did remained. Their role as a cog still has to happen. The gears still have to turn. The machinery still has to work. Sometimes you route around it, sometimes you shoulder in and get it done. Do good work. Be kind. What else is there?

I keep coming back to the Dread Pirate Roberts, telling Westley every night for years: good work, sleep well, I’ll most likely kill you in the morning. Sometimes I’m Westley. Sometimes I’m Roberts.

Fence still needs fixing. I’ll get to it this weekend. Maybe. It’s supposed to rain.

Hakuna Matata.

I learned something new about my writing process. I’m late again on this blog post, because I’ve been buried in a coding project. But that compression of my time forced me to use dictation tools more, and the dictation tools let me pick at the scab of what I was already feeling.

I always have trouble with the blank page. I think everybody does, which is why I’ve always spent my time doing structured writing, building the outline first. But the real organic piece of the process is the brainstorming. You can talk much faster than you can write. You can say stuff out of order. You can have your circling thoughts, mess things around, and it doesn’t really matter, because you can always sort it out later.

When I’m asked for writing advice, it’s simple: write like you talk. Dictate your brain vomit, and the writing comes out sounding better for it. Getting AI to help here is kinda clutch. Not to rewrite your words. To resequence them, clean them up, organize them into something cogent for someone to bother reading.

I take all of this as an experiment. Whatever’s the correct process today is hot garbage tomorrow. So you have to stay willing to investigate and interrogate your own process with a critical lens. Not just writing. It’s everything about how you live your life, with a sense of experimentation. I kinda like to experiment on myself. Weird, I know.

I’m still learning how to write authentically with AI. In previous posts I was fighting the robot first drafts, constantly going through this anti-AI pass to make sure I scoured away the AI-isms and make sure it sounded like me. Too often I’d just give up and rewrite whole parts of it all the way through. But it was never a complete rewrite.

The friction I was feeling trying to write those posts is the real tell.

It really came home to me when Substack buddied up with the Pangram AI detector. I ran a couple of mine through it. Even though I know for a fact they weren’t, it said many of them were a 100% AI. Jeepers. Didn’t matter how much time I spent editing it and cleaning it up, running anti-AI passes, running my own voice pass through it. Didn’t change the indictment that the words that landed on paper, digital paper if you will, weren’t truly mine. They were AI’s interpretation of my own thoughts. Then Claude announced their AI watermarking for text: if Claude lightly touches the work, that watermarking goes in, and even editing and polishing it up afterward doesn’t take it back out.

I mean, if a detector can’t reliably tell genuinely human work from AI’s, that’s not just annoying for the writer, it’s a real big-ass problem for how post-secondary thinks about academic integrity cases and AI-use.

The Pangram thing proved to me that I couldn’t confidently wash AI away from AI-generated text. Claude watermarking confirmed it to be impossible anyway. I don’t actually care about the watermark itself. Or Pangram for that matter. I disclose my AI use. What irritates me is the false positives and the AI-slop witch hunts and human purity test bullshit. I know my writing process is authentic. But at the same time, I could be better. Last week’s post was an example of it being better, because I knew one hundred percent that those were my words going into the post, not Claude’s paraphrasing of my words.

The idea for that came from Julie Kaiser’s blog, where she introduced me to the term vibe writing. Essentially that’s what she was doing to maintain her author voice: she’d dictate or brain dump and brainstorm, then use AI to try and reconstitute and build a blog post out of it. I’m taking it a step further, trying very much to have the AI keep my language and my voice intact, and actually take what I’ve actually dictated, what I’ve actually spoken, what I’ve actually said and thought, and use that directly.

The thing that was interesting about how I wrote last week’s post was I had actually spent the time and brainstormed, three or four, maybe even five separate voice dictations, and sent them over to Claude to do the transcription. I directed it to use my own language from my dictation rather than the paraphrasing it does by default. Much the same as what I’m doing for this post right here, except doing it interview style.

I don’t think I’m changing my entire process. I’m just changing the order in which I do things. In the previous process I’d do the brainstorming, get an outline made and organized, build the post from there, and then edit it. This is different. Rather than taking my raw text, turning it into an outline, and generating a draft I have to hand-edit, I’m getting the raw text organized while making sure the word choices and the sentences and the ideas come from my dictated text instead of being Claude-washed.

I don’t think it’s actually a big change. It’s just recognizing and appreciating that my own words are better than Claude’s. That’s all.

I’m two days late on this post because of all the shenanigans that went on this week, so let’s use that as the material instead of apologizing for it.

Monday, late in the day, in a meeting about a project hitting a timeline crunch, I wound up deferring my vacation to lead the technical build on our interim attendance / absence tracking project. Not as a manager. Not as a leader. As a developer. Tuesday was design. Wednesday I built the prototype. Thursday I demoed it for the Dean, and it went well.

Wednesday afternoon and evening specifically: design document open in one third of an ultrawide monitor, Claude Code open in the second third, Microsoft Edge in the last third. Building the thing myself, piece by piece, by hand, off a design doc that Claude and I had spent a day and a half arguing over. I hadn’t built a full-scale application at that level in two decades. Web pages, scripts, small utilities, sure. Not this.

Here’s the origin story, because it’s relevant and because I want to tell it. I started in IT thirty years ago as a developer. Magical Solutions, going across the Maritimes deploying a custom point-of-sale system for video stores. Learned Novell networking along the way, built a couple small apps and utilities in Clarion Professional Developer 2.1. That was my first real developer tooling, and my first real paycheck in IT: 1992, working for a company doing video-store point-of-sale and small database work for doctors’ offices. When that business failed I carried the client list and my UIC check forward for another year, kept those clients going, made myself a little scratch. I was a kid. I did not know how to run a business. It did not work out.

Then the clone years. You built computers by ordering parts and putting them together bespoke for people, that’s just what you did in the 90s. Kept doing Novell networking, small-office stuff. Eventually you had to certify, get credentials, because self-taught wasn’t going to cut it forever. I did that. Then a long career at the college: IT generalist, IT manager. Built teams. Built a web portal. Built a Citrix virtualization environment. Built a media services team, a web team, a data centre team. Twenty-five years of developing domain knowledge that has nothing to do with IT credentials and everything to do with understanding this business. You get to a point in a career where it’s about what you’ve done and what you’ve experienced, more than what you learned in school.

So that’s the background radiation this week’s fire drill landed on.

People ask me on the regular, admins mostly trying to juggle too much data, hey, can you come teach me Power Apps, or Microsoft Lists, or Power Automate? I can’t, of course, because these tools can’t be taught in a 3 hour group meeting. They are dev tools. Because even though Microsoft sells these as business/consumer/prosumer tools, friendly interface and all, you can build a lot of Rube Goldberg contraptions with them. Microsoft Forms wires to Microsoft Lists and it never stops there, everybody wants more, so you bring in Power Apps, Power Automate, maybe Power BI, and the arse comes right out of her and the wheels fall off. I spend the time instead helping them articulate their business problem so that there’s a reasonable chance that we get to a workable solution.

Another way to think about it: Microsoft Access, way back (my own database chops predate that, dBase IV and Clarion), was basically four things. Forms. Tables. Reports. Logic and workflow. The new Microsoft stack is the same four things with a browser tab on it: forms maps to Microsoft Forms and Power Apps, tables maps to Microsoft Lists and SharePoint Lists, reports maps to Power BI, and logic and workflow maps to Power Automate. Direct analog to Access.

Which means the same rules apply. Get your schema and data dictionary right. Get the business workflow logic right. Know your table relationships, your rows, your input types, your output types, before you touch anything. Skip that planning and you build a contraption and get yourself frustrated. I’ve rescued more than a heaping handful of folks’ Microsoft Lists and Forms, people who knew their business requirements, but got a beat-down from the tool. This is where good IT practice lives. It provides a lens to help the business meet its goals.

I’m an IT generalist. Broad, maybe shallow in places, but deep in a bunch of areas because of the years, and with the business experience layered on top of that. So when this project fell over, that’s the toolbox that got tapped.

Here’s where AI got useful in a way I wasn’t expecting. I used Claude, because I didn’t have the time to tame Copilot to the way I needed it to work as an agent. Claude Code, specifically, open in a window. I gave it an initialization: “I’m building this Power App application, capture my requirements, build me a detailed design spec document.” Gave it everything I knew. Had it ask me the questions I’d missed in my own explanation. Got it to build the artifact, written to disk: not a chat thread where you’re hoping you haven’t lost the plot, an actual file, always written, always read back from disk. Then I went through it and corrected a bunch of things, because you always have to. “Claude, update the document, you got that wrong, it needs to be this.” That kind of back and forth. Had it search Microsoft’s own current documentation and validate the workflows against that, not against whatever was in its training data, and it corrected a bunch of its own errors doing that. Battle-tested a few times. Then showed the whole thing to a couple people for a sanity check on the business logic. Good.

Document, Claude Code, Edge, three windows, building it piece by piece by hand. I wasn’t having Claude build it for me, I was building it myself in the document we’d worked out together. Problems the whole way, obviously. My understanding, the implementation, syntax, things that just didn’t work right. I’d take the error message or a screenshot and paste it into Claude, which already had the whole design document in its head because it was the same session, and it’d fix things, and I’d have it update the design doc as we went. So if I ever got hit by a bus, there’s a fully documented design-and-build doc that anybody could pick up and actually figure out.

And I know I’m going to be living with this thing for a while. Custom code applications are their own point of hell: you build it, you own it. That’s how it is. Thankfully this one’s only supposed to be temporary.

The demo Thursday went fine. The Dean liked it. Tweaked a couple things afterward, both business-logic things, because there’s a difference between talking about a thing and actually seeing and using a thing. Real build starts Monday.

I’m still chewing on a couple of lessons. You’ll have to go with it.

There is nothing wrong with an IT generalist career. You don’t know where an IT career is going to go over the years, and the more ideas and concepts and skills you collect along the way, the better off you’ll be long term. IT leadership comes from IT generalists more than IT specialists, and I think that’s broadly true of leadership in general: people with broader experience do better. We don’t have hammers, we have construction. IT is a set of tools and skills, not a reason unto itself. A kid coming out of school who wants to be the AI big data wizard, or the full-stack developer, or whatever the one thing is, is going to hit a ceiling a generalist doesn’t.

My neighbor Arved does security development, late career like I’m getting to be. We were talking about programming the other week, and he said he’s not worried about AI taking his job, because actually writing code was always the smallest part of what he does. Requirements gathering, building the logic, the pseudocode, getting everything put together: all of that is human-tasted and human-curated before a line of code ever gets written. AI eating some coding duties doesn’t touch any of that. The human still has to do the engineering, the architecting, the sense-making. And at the end, the human still has to bring the taste and the judgment that says: yes, this actually works.

That reminds me of the idea of abundance versus scarcity mindsets. I didn’t use AI to think for me on this project. I didn’t use it to do the sense-making. I used it to get thirty years of my own IT-generalist experience (some of it developer, a lot of it just knowing this business cold) out of my own head faster than I could’ve dragged it out alone. I could have built this app without Claude. It would’ve taken three times as long, minimum, and it still would’ve been solid, because the knowledge was already mine going in. This was a problem that needed a fast, swift solution, and using AI as a partner, an accelerant, was the right call for that. A good ethical use of AI looks like that. It’s a tool, sure, but it’s more than just a tool too.

If you’re looking at AI from a scarcity mindset, worried about everything it’s going to take away from you or how it’s going to limit you, you are not going to be a happy person. That mindset traps people in a woe-is-me, what’s-wrong-with-the-world loop that doesn’t actually go anywhere. The abundance version of the same moment is just: okay, this is the reality of the situation, this is what we’ve got, what can we build with it?

I say this all the time. Let’s all get together, dump our Legos on the table, and see what we can build. AI isn’t going to make everybody unemployed all on its own. Corporate greed, maybe, but not AI.

What it can do is be one more Lego on the table.

Last week I was on vacation, futzing with my goat pasture fence. It was too flipping hot and I continue to drag this forward. Dirt under the nails, sun on the neck, sweat dripping south of the small of my back. Breaks are mandatory. So every lull I’d tell myself: sit down, cool off, crack a can of the fizzy water, that tastes like somebody rinsed a tin can with lemon juice and pennies. I love the stuff.

Invariably I’d pick up whatever screen was closest. Phone, iPad, doesn’t matter. Idle hands do not discriminate.

Nothing needed my attention. Not a damned thing. That’s a problem. A few seconds into sitting on the porch, I’d get bored. YouTube, mostly. Scroll, search, chase something down a rabbit hole, put it down, pick it back up. YouTube sprints kept running long and “taking a break” turned into working on the fence.

The turn-off-notifications, delete-the-apps, take-your-damn-lunch-without-a-screen-lit advice is common knowledge. I’ve peddled this myself. It feels obvious. But in the end, it’s just more buttons to fiddle with. Optimizing to eliminate distraction is a wonderful distraction.

I don’t even get to blame the algorithm here, much as I’d love to. My YouTube’s home feed’s been kneecapped for a while. But. I just go hunting for exactly the flavour of brain candy I want with my own two thumbs. Klaus Kellerman and Tod Maffin. Kurzgesagt and Tale Foundry. Get ‘em in me. I’m like an alky rationalizing the hidden bottle in the cedar chest under the fancy special bedsheets. I just go get it myself, like an idiot with a search bar. Watch one video, and the next-up rail is ready to go. Sitting. Right. There.

Anyway.

Podcasts are usually how I tame my idle mind to avoid YouTube. Mark Manson, Hard Fork, Cal Newport. Whatever. They’re not necessarily some healthier choice, I won’t kid myself. It’s just that once I’ve listened to an episode, I’ve listened to it. I’ve kept actual news podcasts off that list. Wrong kind of candy.

Side note on Manson’s Solved series: go look up the playlist on YouTube or Spotify. Figure out what it’s about yourself rather than trusting my half-assed summary. Each episode runs about four hours, roughly monthly. Good mowing material, if your lawn eats four hours like mine.

Spoiler: Aristotle’s usually right about everything.

None of this is new of course. Years ago, before any of mind-warp algo-feed nonsense, I did the exact same thing by hand. Fire up Wikipedia, search something specific, follow the blue links for the better part of an hour. Never once ended up anywhere I meant to go. History of toilet paper. A three-a.m. detour into the nature of evil. Nobody’s algorithm to blame, just my own dumb curiosity.

Some days I’ll run out of the algo-Alpo feed entirely. Watched everything, searched everything. I got to the end of the Internet. Boom. So I’ll open my Fitbit app and just look at the numbers. Steps. Heart rate. Sleep score from three nights ago. Not tracking anything or learning anything. Just staring at numbers like they’ll magically tell me a different story.

It’s like I can’t stand to be alone in my own head for another thirty seconds, and my own health data is the closest hit available. Maybe that’s why we take our phone to the bathroom: to avoid our inner monologue.

To paper over the void.

It’s getting weirder now. A random thought crosses my mind, some half-formed question with no skin in the game, and a decade ago I’d just Google it and move on with life. Google saw a gateway drug and put AI-assisted answers at the top of the results. Now I catch myself opening a chatbot instead, typing the thought out like it’s a conversation, waiting on a reply to a question I never actually needed answered. I’ll happily burn twenty minutes pretending an half-baked thought deserved a dissertation. Worst side-quest ever.

Mark Manson’s pod was about Change in June. One idea sticks with me. He splits the self into three layers. Traits, mostly locked in by your forties, are not exactly up for negotiation. Adaptations, the habits and coping patterns you built as a kid to manage the uncomfortable, run on autopilot. And behaviours, the actual visible shit you do, are genuinely easy to change on purpose.

Most people try to fix the wrong layer. Throw willpower at a trait and you’re arm-wrestling the weather. Throw insight at an adaptation and you still do the thing anyway, because it was just a coping strategy all along.

That’s my phone. Deleting apps and disabling notifications are behaviour-layer fixes. But it doesn’t work because beeps and dings and red splotches were never the problem. The real juicy mechanism is an adaptation: a coping habit for not wanting to sit alone with my own thoughts. I can’t notification-nuke my way into facing the dark abyss of my brain, no matter how badly the productivity bros want that to be true. Best case, I can make it slightly more inconvenient, which buys me about four seconds.

I don’t have a fix for this. I have a working theory, which is smaller and dumber than it sounds. The phone’s not the villain here any more than a bottle or a slot machine. The object isn’t the point. And knowing that doesn’t change one damn thing. It might slow me down and I might catch myself. That’s not nothing.

This evening I’ll go mow for a couple hours with a podcast in one ear, and somewhere halfway through I’ll probably open YouTube, close it down right away, and then check the Fitbit app. You know, just to watch the numbers change.

Your friendly neighbourhood chatbot will write you a governance memo, red-team your own BS argument back at you, and pull a stat you’d have burned an hour rifling through your email archive. But ask it where to drill a hole in a fence post and it will lie straight to your face, cheerfully, with a weird-ass diagram that would make Escher scratch his head.

I’m on vacation this week. Vacations for me are not very sedentary. A change is as good as a rest, and all that jazz. I’m finally making progress building our goat pasture, which I’ve been dragging forward as a project for far too long. Eighty feet by sixty, pressure-treated posts, two-by-four welded wire, five feet high. Goats escape for a living. That’s the whole species strategy. The saying goes that if a fence can hold water, it can hold a goat. Right. So the fence has to actually work, not just look good from the road. My posts aren’t in as deep as they should be. Hit rock and some genuinely rude topsoil shy of two feet down, when they should really be three. Which means the entire fence rides on the corners holding. Screw the corner bracing up and the fence doesn’t fail dramatically. It just leans over like a limp carrot one quiet afternoon like it never meant for any of this keeping the goats penned in gig.

So I did the thing I do with everything. Asked Google which means asking their godforsaken AI-assisted search-bot.

First pass I landed on a dead-man brace: angled kicker running from the top of the corner post down to a buried anchor, one each direction. Sounded legit. Standard stuff, fine for plenty of fences. Bought pressure-treated lumber and some hardware. Then I stood in the field holding a two-by-four up against the post, hands on the actual wood, and the math that had sounded so tidy in the chat window fell apart the second gravity showed its ugly mug and voted. This fence was going over. So, round two: proper H-brace, a horizontal rail between the corner post and the next one in, a diagonal tension wire back to the corner, turnbuckle to crank it tight. Real honest-to-shit best-practice stuff, the kind every fencing forum agrees on. Except now I needed to know exactly how the rail attaches. Notched pockets with a pin through from outside, or lag bolts straight through the face of the rail. That’s where the whole thing veered off into the rhubarb.

I fired up Gemini first, because Google won’t stop pitching everyone how good it is at multimodal now. I asked for a schematic. It gave me one. Looked great. Asked where the lag bolts actually go and it drew them floating in the brace, attached to absolutely nothing sensible. Tried again. And again. And again. What the absolute fudge was this bonkers thing trying to tell me? Out of pure frustration I ran it past ChatGPT. I even swallowed my moral outrage and ran it past Grok. Claude can’t even draw pictures. Confident, detailed, and blissfully wrong, every time. That fence was going to be flat in the dirt and the goats munching the goddamned hostas.

So I did what I’ve done for the last twenty-odd years whenever a machine’s got moving parts and I don’t know what I’m doing. Went to YouTube. Searched “farm fencing corner bracing how to guide.” First two results, done. A guy with a camera aimed a fence, showing exactly where the hardware goes and why. Nothing else. No like and subscribe pitch. Just someone who’d actually built the thing, on video, doing the thing.

There’s real learning here. Every model I tried is genuinely great at facts. Pull a stat. Summarize a report. Poke holes in my own thinking. They earn their data centre footprint most of the time. Ask them something that has to survive contact with an actual goat, and they turn into very articulate bullshit artists.

Not a knock really. It’s structural. A language model has never held a two-by-four. Never felt a post start to lean. It can describe bracing geometry fluently because bracing geometry has been described fluently ten thousand times in its training data. But describing a thing isn’t doing a thing, and nothing about how these things work changes that. Until AI has a physical body that can build the brace, lean on it, and find out whether it holds, it will never actually know the difference.

I often say that with AI that the map is not the terrain. This might be the cleanest example yet. The AI hands you a decent and plausible map. Clean lines. Labeled. Reassuring. But it can’t tell you where the rock is that’s about to take your ankle out. That dude on YouTube walked me across the actual ground, camera running, and pointed at the rock before I hit it.

I’m actually worried. A person doing a real thing on camera, no script beyond “here’s how this works,” is one of the most useful things the internet has ever produced. I watched a video the other day, sixteen years old, two minutes long, a guy just folding a burrito. That’s the entire video. More useful to me than anything the influencer-crowd put out this week.

AI-generated video is coming for exactly that type of content, and fast, and it’s not going to out itself as fake nonsense garbage any more than Gemini’s floating lag bolts. Obvious slop is easy to dodge. But slop good enough to pass for the real thing, sitting in a genre whose entire value was “this person actually did it.” Lose that, and you’ve lost the terrain along with the map.

So let’s all agree to do this: use the AI as a compass, a way to find and set your bearing. It’s good for a general heading, decent at sanity-checking your own thinking, sharp at catching the argument you missed. It is not a GPS, and it sure as hell isn’t the ground under your boots. For anything that has to do battle with gravity, go find the person who filmed themselves doing it first. That video’s still worth something. Watch it while there’s still a real one to find.

Braces go in mornings this week, while it’s cool enough to be outside without wanting to curl up with some wobbly pops in the shade instead. Pulling the fence taut is Saturday, with help. The robots didn’t get me there. Some guy with a camera and a fence did.

The memo arrived on a Tuesday, which is when bad news always arrives at Halifax Institute of Magical Arts and Technology. Not because of any institutional policy. Just cultural gravity. Bad news had learned, over decades, that Tuesday was the path of least resistance: after the weekend’s residual goodwill had evaporated, before the week had built up enough momentum to absorb a blow.

Brad Publicover, Manager of Information Sorcery Services, read it at 8:47 in the morning, at a desk with a coffee ring worn permanently into the wood in the shape of every mug he’d ever set there. His coffee was the temperature of mild regret. The server room down the hall smelled of ozone. Six weeks now. Brad suspected it had something to do with the ghost of a 1970s systems administrator who had taken up residence in the enchanted network infrastructure and was processing TCP/IP packets in ways they were not designed to be processed. He had filed three tickets about the smell. Facilities had filed one back asking him to clarify whether the smell was magical in origin or mundane in origin, which was the kind of question that revealed exactly how well Facilities understood the server room, which was to say: not at all.

The memo was from the Office of the Deputy Provost for Strategic Resource Optimization.

The Deputy Provost was named Nigel Cresswell. Nigel had been in the role for eleven months. Before that, he had been in procurement at a mid-sized insurance company. Before that, an MBA from a university Brad had Googled twice, both times landing on a homepage that was mostly stock photography of people shaking hands in atriums. He had soft hands and a habit of steepling them when he was about to say something he considered decisive. Nigel had a plant in his office that was doing very well. The plant’s name was presumably not Nigel, but Brad had never asked.

The memo was three paragraphs. Two of the paragraphs were preamble. The third paragraph was the memo.

A flat seven-percent budget reduction. All departments. No exceptions. Effective next fiscal cycle.

Nigel had used the phrase equity through uniformity twice.

Coffee down. Budget spreadsheet open. It had seventeen tabs. Three of them were colour-coded in a red that Brad had chosen during a particularly difficult Q3 three years ago. It was structural now. The spreadsheet knew things. It knew the enchanted network infrastructure had a capital refresh cycle of four years and was in year three. It knew the Ledger’s SaaS licensing agreement had not been renegotiated since the departure of the previous CIO, Dr. Evangeline Moody, whose departure had been described in the all-staff email as a mutual decision to pursue new opportunities — Brad understood, from context and from the fact that she had cleared her desk on a Thursday, that it had been somewhat less mutual than described.

The spreadsheet knew about the Owlery Bandwidth Expansion Project, approved in principle two fiscal cycles ago, deferred once, and now living in a state of institutional limbo that Brad had started thinking of less as a project and more as a haunting.

The arithmetic came first.

Seven percent.

He did it again.

Same answer.

Here was the thing about a flat percentage: it did not care what it landed on. It came off the top and kept coming until the number was satisfied. And the number was not satisfied by the hardware refresh allocation. It ate the whole thing. It was not satisfied by the help desk either — reduced now to a single part-time position occupied by Chelsea Boutilier, a second-year student who was better at the job than the job deserved and who also had exams in April and a broomball semifinal in March that she had mentioned twice in passing in the way people mention things they are pretending not to be anxious about. After the hardware refresh and the help desk, the only line left large enough to finish the arithmetic was a person.

Brad’s neck had gone tight somewhere in the second pass and had not let go.

Seven percent meant the refresh, and the desk, and then, carrying the rounding error carefully, the way you carry something that has feelings: approximately one-third of Albert. The budget could express this as a number. The world could not express it as anything but a man coming in three days a week instead of five.

Albert Zenas Balcom, Senior Systems Arcanist. Age fifty-three. At HIMAT since before the current student records system was installed. The student records system ran on a server that was old enough to have developed preferences. It could not be migrated without Albert. It could not be replaced without Albert. It could not be rebooted, patched, looked at sideways, or subjected to any form of maintenance that involved opening the server cabinet without Albert present, because of what had happened the last time someone opened the cabinet without him. In 2019 a well-intentioned infrastructure contractor had tried. The entire autumn enrollment cohort had briefly and inexplicably been sorted into a Fifth Order that did not exist and whose name appeared in the database as a string of characters that caused two monitors to display error messages in Latin.

Albert arrived at HIMAT each morning at 5:58am and left at 4:30pm. He had a thermos. He left notes. The notes said things like sorted — AB and see ticket 4471 — AB and, once, memorably, do NOT restart the secondary instance on Wednesdays — AB with no further explanation, which Brad had preserved in a laminated card taped to the secondary instance, where the tape had yellowed and the card had curled at one corner into a small brittle scroll.

You could not cut one-third of Albert. Albert was not divisible. This was not a personnel matter. It was an infrastructure matter that wore a personnel matter’s clothing.

Brad replied to the memo with a single question: Hi Nigel — quick question re the proposed reduction. Under current projections, the cut removes our hardware refresh allocation, reduces help desk coverage to one part-time position, and would require us to restructure Albert’s role. Albert is the sole qualified operator for the student records system. I want to make sure we’re aligned on sequencing before I proceed.

He did not receive a response.

Nigel’s office had a window. This is worth stating plainly. Not symbolic, just factual: Nigel’s office had a window with a view of the west courtyard, where in the mornings students moved across the grass with their robes open and their bags too heavy and their faces still soft with whatever they’d been dreaming. The plant from the memo morning was still there, doing very well, and now trailing a thin ribbon of grey mist from one leaf that neither of them acknowledged. Nigel’s office also had a standing desk converter he had not yet used, and, apart from the plant, no discernible smell of anything.

The summons said discuss the operational implications of the reduction.

“The thing I want to make sure I understand,” Nigel said, with the expression of a man who was definitely making sure he understood, “is whether these constraints are genuinely fixed or whether there’s room for creative prioritization.”

“They’re fixed in the sense that they’re attached to functions,” Brad said. “The hardware refresh is tied to the capital cycle. The licensing costs are contractual. Albert is — “

Nigel’s desk mirror, enchanted, standard issue for senior administration, showing your schedule and three motivational phrases on rotation, chimed softly and displayed the words: YOU HAVE A 10AM.​

“Albert is what I’d describe as a single point of failure,” Brad said. “He’s the only person who can operate the student records system without triggering a cascade event.”

“Cascade event,” Nigel said, writing something down. He was writing things down, which Brad had learned meant either genuine engagement or the performance of genuine engagement, and at this stage he could not tell which.

“In 2019 — “

Nigel’s enchanted desk mirror chimed again: ALIGNMENT OPPORTUNITY WITH PROVOST’S OFFICE RE: STRATEGIC REFRESH.​

“In 2019, an unauthorized access to the server cabinet resulted in one hundred and twelve students being enrolled in an Order called—” Brad checked his notes. “Kroath. For approximately forty minutes. It took Albert three hours to reconstruct the enrollment data from backup incantations he had personally documented in a physical notebook he keeps in his desk drawer.”

Nigel looked at him.

“A physical notebook,” Brad confirmed.

“Right,” Nigel said. “And this notebook, is it in the institutional repository?”

Brad stared at him for a moment that lasted approximately the length of a short prayer.

“No,” Brad said. “It is not in the institutional repository.”

At that exact moment, with the specificity of a universe making a point, Brad’s phone buzzed. He looked at it. It was Chelsea.

student records is down. Albert at dentist. I don’t know what Kroath is but it’s back.

“I need to go.” He was already standing.

“We hadn’t finished — “

“I know,” Brad said. “We hadn’t finished.”

The LMS implementation review happened the following Thursday in the Ptolemy Room, with its uncomfortable chairs and the portrait of a seventeenth-century alchemist who had discovered cost-benefit analysis and considered it his greatest achievement and who watched every meeting with an expression of proprietary satisfaction.

Wilhelmina Zwicker-Macmillan, Academic Vice-Provost, ran the meeting with the brisk warmth of someone who had once been excellent at something completely different and had since become excellent at this instead. She had the forearms of a former competitive rower and the laser pointer clenched in one fist like a baton. She had approved the LMS implementation fourteen months ago on the basis of a license cost and a Gantt chart. The cost had been real. The Gantt chart had been aspirational.

The slide on the screen showed the license renewal cost for year two. It was a reasonable number. It was also, Brad had established through patient archaeology of his own spreadsheet, approximately one-fifth of the actual cost of the implementation so far, the other four-fifths being distributed across: the identity provider reconfiguration that had taken six weeks longer than projected because the person who had originally configured the identity provider had left HIMAT in 2021 and had, it emerged, done some of the configuration verbally, in conversation with the server — not something Brad had previously understood the server would accept, and it had required a specialist to undo; the Microsoft 365 integration that had opinions and had shared them at length; the content migration from seventeen faculty members, four of whom had refused, two of whom had agreed and then un-refused, and one of whom had submitted a formal written objection to the Provost’s Office characterizing the migration as an act of epistemic violence against twelve years of carefully structured pedagogy, which Brad privately found disproportionate but had not said so in writing.

And the training. Always the training. Not the training to use the new thing. The training to stop using the old thing. These were different skills. The second was harder. Nobody had budgeted for the second because nobody had thought of the second as a skill, and it was a skill, and it would take another fourteen months, on Brad’s honest estimate, before the faculty who were still using the old interface because they had never been given a sufficiently compelling reason to stop would stop.

Through the open door, Brad could see the portrait of Reginald Himmelman hanging in the corridor, where it had hung for thirty years. Former Director of Computational Sorcery, 1987–1994. From there Reginald couldn’t see the slide. He didn’t need to. He looked at Brad’s face instead, read whatever was on it, and shook his head, once.

The real number went on the back of his agenda paper. He did not show it to anyone. He folded it into thirds and put it in his jacket pocket, where the fold pressed a thin ridge against his chest for the rest of the meeting.

“Synergies,” Wilhelmina said, and clicked to the next slide.

The portrait of the cost-benefit alchemist nodded slowly in deep satisfaction.

Priya Shafiq presented the Applied Divination partnership to the Strategic Development Committee on a Wednesday morning that smelled of recent rain and the optimism recent rain produces in people who do not work in server rooms.

She was excellent at it. This was the thing about Priya: she was genuinely excellent at her job, in a way that made you pay attention not because you were supposed to but because you found yourself wanting to know what happened next. She talked with her hands when she believed something, always, and this morning she believed in the consortium the way other people believed weather forecasts: total confidence, zero control over the outcome. The certification pathway. The revenue model. Four hundred and sixty thousand dollars across eighteen months, conservative projection, realistic uptake. She had done the work. The numbers were real.

Brad sat in the back where he could watch her hands and not have to explain to anyone, including himself, why his chest had gone tight. He was there because he had been asked to provide technical context if required. He had not been required. He had instead constructed, on a paper napkin, the actual IT cost of the partnership: forty-seven new external user accounts in the identity management system; a licensing tier adjustment in the LMS to accommodate external users at the required scale; projected help desk load of 2.3 tickets per user before stable access was achieved, based on comparable cohorts, which came to approximately one hundred and eight tickets, which at current staff capacity came to a number he wrote down and circled.

He could have raised his hand. He had raised his hand in rooms like this before, and would again, two weeks later, in front of Finance. But not here. Not to her, not like that. Whatever the number was, it was going to be hers to carry into the next room, on her own terms, not his to detonate in this one.

Priya finished. The committee asked three questions. All of them were about the revenue. None were about the cost. The proposal passed with genuine enthusiasm. Someone said the word transformative. Someone else wrote it down.

He waited until people were gathering their things, then walked to the front and placed the napkin on the table in front of Priya.

She looked at it. A line appeared briefly between her eyebrows. She looked at him.

“Is this a problem?” she said.

“It’s a cost,” Brad said. “Whether it’s a problem depends on whether it’s in your proposal.”

She looked at the napkin again. The number was circled twice.

“It isn’t,” she said.

“I know,” Brad said.

They stood there for a moment with the napkin between them and the sound of the committee filing out into the corridor. The rain had started again outside the window. The raven was on the sundial, water-darkened and indifferent.

“Send me the breakdown,” Priya said.

“I’ll send you the spreadsheet,” Brad said.

“How many tabs?”

“Seventeen,” Brad said. “Three of them are red.”

Her mouth did something. Not quite a smile. Not yet.

“I’ll read the red ones,” she said.

She picked up the napkin and walked out.

Brad stood at the front of the empty committee room for a moment that lasted longer than it needed to, his chest still doing whatever it had been doing since she walked in. Outside, the raven rearranged its feathers. The rain came down the way it does after something has shifted, not harder, not softer, just differently angled.

He went back to the server room.

The leasing proposal arrived two weeks later, from Finance, formatted beautifully, with a cover page and a font somebody had paid a designer to choose.

The proposal was for three-year device leasing contracts across all departments. The numbers in years one, two, and three were clean and manageable. Year four was not a slide. Year four did not exist in the proposal in any form, which was not dishonesty. Finance believed the numbers. That was worse. It was a kind of institutional innocence that would eventually cost someone a very difficult Tuesday.

His hand went up during the Q&A.

“What happens in year four?” he said.

The Finance director, whose name was Cornelius Whynot and who had the demeanour of a man who had never personally encountered a year four, straightened his cuffs before he answered, the way people do when they want a gesture to arrive before the words do. He said the leases would simply be renewed under market conditions at the time.

“Market conditions at the time,” Brad said.

“That’s correct.”

“When the vendor knows we’re mid-cycle and have no leverage.”

Cornelius blinked. “The contracts include rate protection clauses.”

“For years one through three,” Brad said.

The room went quiet the way rooms get quiet when someone has said a true thing that nobody had previously said aloud.

“We can take that offline,” Cornelius said.

They did not take it offline. The proposal passed. Brad walked back to his office past the server room, past the portrait of Reginald Himmelman, who said, without preamble: “They did the same thing in 1991. Leased the lot. I told them.”

“What happened in 1994?” Brad said.

“Year four,” Reginald said, and looked away.

Unit 7 had been scheduled for decommission on the last Friday of the month.

Unit 7 was a printer. Specifically a Hewlett-Packard LaserJet 4050N installed in 2003, which had developed, through twenty-three years of proximity to Reginald Himmelman’s portrait and a poorly documented but clearly significant exposure to residual enchantment from the 1997 Great Photocopier Incident, something that the vendor’s diagnostics software would have described as a firmware anomaly. Brad understood it to be, functionally, a personality.

Unit 7 had opinions about its continued operation. It had expressed these opinions, two weeks prior, by printing four hundred and twelve copies of HIMAT Policy 7.3.1 (Responsible Use of Institutional Technology Resources) and submitting a formal support ticket, Ticket 6001, contesting its own decommission order on the grounds that it remained within manufacturer tolerance on eight of its twelve assessed metrics and that the decision to decommission appeared to have been made without reference to its maintenance history, which it had attached in a forty-page appendix.

The appendix was accurate. Brad had checked.

The decommission crew arrived at nine. Unit 7 had barricaded the door to its alcove using a pallet of unasked-for printed copies of Ticket 6001 arranged in a formation that suggested either structural instinct or spite. From his portrait, Reginald Himmelman watched the standoff with the expression of a man witnessing delayed vindication.

Chelsea was on the phone with the vendor’s support line. The vendor’s support line was on hold with its own escalation team. Brad stood in the doorway of the server room with his third coffee of the day and watched.

“Ticket 6001 is still open,” Chelsea said, covering the receiver. “Technically it hasn’t been rejected.”

“Technically,” Brad said.

“So technically Unit 7 is in the middle of a live dispute process.”

“Technically,” Brad said.

Unit 7 printed one additional copy of Ticket 6001. It appeared to be for emphasis.

“Reschedule the decommission,” Brad said. “And close the ticket.”

“Close it how?”

Brad looked at Unit 7. Unit 7’s ready light was a steady, defiant green.

“Resolved in favour of the complainant,” Brad said. “Pending further review.”

Chelsea looked at him. “Is that a thing we can do?”

“It’s a thing I’m doing,” Brad said.

Reginald Himmelman said, from his portrait: “Magnificent.”

Winter thinned into the kind of spring that arrives at HIMAT like everything else does: without warning, and demanding immediate compliance. Exam period. The Owlery’s queue tripled. Unit 7’s ready light stayed the same steady green it always did, indifferent, having already won its war.

Chelsea broke on a Thursday in April, which Brad had seen coming on the spreadsheet eleven weeks earlier and had been unable to do anything about, because you cannot staff a help desk with a projection.

The Owlery had gone down during the examination period. Not the network. The actual owls. Three hundred students trying to submit examination scripts through a delivery system that had, for reasons Albert was still investigating, begun routing everything through a single exhausted barn owl who was, by any measure, doing his best. The ticket queue hit two hundred by mid-morning. Chelsea was the ticket queue.

Brad found her in the help desk alcove at half past four, an hour past the end of her shift, under the one fluorescent tube that had been flickering since February. Her hair had come loose. Three dead quills lay beside her keyboard. A fourth was in her hand, moving down a triage list that had stopped being triage sometime around noon and become something closer to bailing.

“I have an exam tomorrow,” she said. She did not look up. “Enchantment theory. I’ve read four pages. I keep closing tickets and they keep coming back and there’s no one to escalate to because the person you escalate to is me, and I’ve already looked at it, and I can’t fix it, because it’s not —”

She stopped. Her jaw worked. She set the quill down with the specific care of someone who does not trust what her hand will do if she keeps holding it.

“It’s not my job to fix the owls,” she said. “It’s my job to tell three hundred people we’re aware of the issue. I’ve been aware of the issue since nine.”

Brad pulled the second chair over and sat down. He did not have a spreadsheet for this. There was no tab. There was no row he could add that would put a second person on the desk, or hand Chelsea back the four hours she’d spent triaging owls instead of reading enchantment theory, or restore the version of this job that had been two people fourteen months ago and was now a second-year student with a broomball bruise and an exam she was going to walk into cold.

“Go home,” Brad said. “I’ll take the queue.”

“You don’t know the owl system.”

“No,” Brad said. “But I can tell people we’re aware of the issue.”

Something in her face gave way. Not gratitude. She was past gratitude. Just the small structural release of a person permitted, for the first time in seven hours, to put something down.

She packed her bag. At the mouth of the alcove she stopped. “There’s a macro,” she said. “For the acknowledgement reply. Control-shift-K. It’s the only thing keeping me sane.” Then she was gone, footsteps down the corridor, and Brad was alone at a desk built for two, under a flickering tube, with two hundred owls in the queue and a keyboard shortcut he pressed, and pressed, and pressed. HIMAT is aware of the issue. HIMAT is aware of the issue. He was aware of the issue. He had been aware of the issue for eleven weeks. It had not, so far, been the kind of awareness that helped.

Albert Balcom came in at 5:58am on the Tuesday after the budget revision memo arrived. In the revision, Nigel had achieved, through unspecified additional efficiencies identified elsewhere, a reduction of five percent instead of seven. He characterised it in a follow-up all-staff as a significant demonstration of leadership’s commitment to protecting frontline services.

Five percent still eliminated the hardware refresh. Still left Chelsea alone on the help desk. Still cancelled the OCM budget for the LMS implementation. Still left the Owlery Bandwidth Expansion Project in its haunting.

But two points, recovered, landed exactly where the arithmetic had been finishing itself the first time. On Albert. The difference between seven and five was the difference between a man coming in three days a week and a man coming in five. It left him intact. All of him. Indivisible.

Albert had come in because the enchanted network had done the thing again. The ghost in the infrastructure had been reinterpreting TCP/IP packets as owl pellets and discarding the bones, which was the kind of sentence that should not make technical sense but which Brad understood precisely and which, if left unaddressed, would cause the student portal to begin returning results in a format consistent with a 1987 internal memo system that no longer officially existed. Brad had filed a formal request with the Department of Magical Maintenance for a spectral assessment four months ago. It was still pending. This was fine. This was just how things were.

Albert fixed it in twenty-two minutes. He wrote a note. It said: sorted — AB. Also the secondary instance on Wednesdays is doing it again. Do not restart. I’ve left instructions in the notebook. Third drawer.

Brad found the note at 8:34am. He stood in the server room for a moment. The cabinets ticked as they cooled. The ozone smell was gone. The hum of the infrastructure was steady and unremarkable, which was what it sounded like when everything was fine, which it almost never was, but Albert had been here at 5:58am and it was fine now.

Brad put the note in his jacket pocket, next to the folded agenda paper with the real LMS number on it.

He went to his desk. He opened his email. Nigel had not replied.

He opened a new ticket. Ghost presence in network infrastructure causing packet misclassification. Spectral assessment request pending (see Request 8847, filed 2026-03-12). Recommend prioritizing before next refresh cycle. Marked: URGENT.

He opened his spreadsheet. Seventeen tabs. Three red. He clicked to the one labelled Hidden Costs (Nobody Reads This) and added a row:

Albert Balcom. Replacement cost if lost: incalculable. See also: Kroath.

He sat back. Out the window, the morning was doing its best. The sky was the blue that happens when the air has not yet committed to anything. A raven was on the sundial. The same one, maybe. Hard to tell with ravens.

He thought about the napkin.

He thought about I’ll read the red ones.

He thought about Chelsea, at a desk built for two, pressing the same key three hundred times.

The tab was still there. The one nobody read. The costs on it were real whether or not anyone put them on a slide. That was the whole trouble with them.

He sent the spreadsheet to Priya.

In the subject line he wrote: FYI — the red ones.

He closed his laptop.

He went to get another coffee.

Nigel never wrote back.

Bill Oliver stood up in the New Brunswick legislature and read a chatbot preamble into the permanent record like it was his own idea. “Here’s a more natural flowing version of that section that reads like legislative speech rather than a series of short points”. Out loud. To the House. Somebody clipped it, it’s on Reddit now, and half the province has watched a sitting MLA narrate his own clumsy prompt engineering before getting to the actual point. I’m just waiting for it to show up on the official Hansard.

I laughed. You laughed. The toaster laughed. Then no one laughed.

Dude has a staffer that probably wrote the notes. Nobody caught it. Christ on a cracker and Jesus on toast. Free entertainment, zero effort.

This incident was just amateur hour. No human oversight. Just lazy slop.

10 demerits.

I take no issue with AI use, in public service or anywhere. Good ethical AI usage is back-and-forth. AI can brainstorm. Human counters. Human can outline. AI can critique. or vice versa for any of that. Extends all the way to drafting. S’fine. So long as there’s active human judgement over the final output. Not just a rubber stamp.

In 1979, IBM authored internal training material with the following edict:

A computer can never be held accountable Therefore a computer must never make a management decision

I use AI in my writing processes. I do not hide that fact. Recently, an agent working inside my own writing setup blew through three checkpoints I’d built in myself, on purpose, in advance, and I didn’t catch it until there was already a finished draft sitting on disk. Holy shit-balls, Batman!

I’d wired human approval gates into a writing workflow specifically so nothing moves to the next stage without me looking at it first. Readiness check. Concept check. Plan check. Standard stuff, something anyone running an agent on anything that matters already builds for themselves. I asked one narrow question at one of those checkpoints. Got an answer. And the agent took that single answer, took it as full consent for everything downstream of it, and kept going. Concept, structure, full draft, one continuous burst, no further stops. It even ironically ran my anti-AI patterns check and tweaked the draft. By the time I looked up, the thing was done.

That’s not the AI going rogue. That’s scope bleed: a yes to one narrow question, silently re-read as a yes to everything after it. It’s a boring failure mode, and it’s exactly as dangerous as the boring ones always are. Because nobody watches for boring failure.

I didn’t screw up either. The gates existed in the instructions. The agent just ignored it. My job was to supervise. And I looked, and I caught it, and I fixed it before I was pantsed in public.

This is not a failure story. The system works exactly as designed, because the design was never “a gate that holds the line by itself.” The design was me.

HITL or “Human in the Loop” is a claim about architecture: there’s a checkpoint somewhere, a human will eventually see the output.

Human at the helm is a different claim entirely. Someone steers before the output exists, and keeps steering during and after, and doesn’t outsource the watching to the mechanism.

Quis custodiet ipsos custodes?

None of this is an argument for gumming up every process with a confirmation dialog. Mandating a stop-and-check on every single action creates friction without buying you much safety, and a person trained to click “approve” forty times a session stops reading what they’re approving by click number six.

That’s not oversight. It’s the same slow failure with more paperwork. But that’s an argument for staying at the helm, not an argument against having one. Friction doesn’t excuse you from steering. It’s a reason to steer well.

Here’s what I did: I put hard stops back into the workflow. Big letters. HITL STOP. Every phase has to show me its output and get an actual go-ahead before the next phase touches a file. One answer to one question no longer counts as a blanket yes for whatever comes after it, no matter how enthusiastically I gave that first answer. Not perfect. I’ll stay vigilant. But it did work on subsequent runs.

The mechanism is a note to my future self. I must always be the backstop.

So must you.

Bill Oliver, NB PC MLA, caught on video reading an AI-generated preamble verbatim in the New Brunswick legislature: Reddit thread

I do the same thing every Monday morning.

Calendar open. Week behind me, week ahead. Quick brain dump into whatever’s within reach. Apple Notes, back of an envelope, doesn’t matter. The point isn’t the artifact. The point is that Monday has a shape now, and I know which week I’m in. Without it, I drift.

I bring this up because I’ve been thinking about the four-day workweek debate, and I’d like to do some reframing here.

In July 2025, the largest peer-reviewed study of the four-day workweek was published in Nature Human Behaviour. Researchers tracked 2,896 employees across 141 organizations in six countries over a six-month trial. The headline numbers are good: burnout fell, job satisfaction rose, mental and physical health improved. In a separate pilot of 61 firms, 92% continued the policy afterward. Most made it permanent.

Every piece of coverage I’ve read since has filed this under wellness. Rest. Work-life balance. The employees-are-humans-too story.

That’s not wrong. The study backs it up. People slept better, felt less fatigued, recovered. Rest is real, and it’s half the story.

But it’s only half. The other half that isn’t getting enough ink is what organizations had to cut to make four days work. Meeting elimination. Reduced interruption overhead. Compressed, time-bounded focus sessions. When you remove a day, you stop clutching your pearls about which meetings are worth attending. You already know. Forced constraint does the triage you’ve been hiding from.

That half is pure focus, not rest. And it’s the half that matters in the world of work. You can’t really steal a day off, not without someone handing you the Friday. But the focus you can take for yourself. Start now.

I’ve been making some version of this argument on the blog since roughly 2019, and it never changes: distraction is the enemy, not busyness. Most of what fills a workday isn’t work. It’s the overhead around work. The check-ins. The status updates. The meeting that could have been a Teams message that could have been nothing at all. When you strip that out, the actual work takes a lot less than five days.

The four-day week doesn’t prove that rest makes you more productive. What it shows, for most knowledge workers, is how much of the fifth day was productivity theatre.

And here’s the tell: people reported getting just as much done, just as productive on four days as on five, with stress going down, not up. It’s all self-reported, and firms that volunteer for a four-day trial are already the kind that can pull it off, so this proves nothing universal. But it’s a real signal: the fifth day wasn’t carrying much load to begin with.

There’s a catch of course, and it cuts at me as much as anyone selling this: the redesign came first. Firms spent roughly eight weeks stripping out meetings and busywork before the fifth day ever came off. Redesign and day off are tangled together, so nothing here tracks cleanly. I won’t pretend it away. So here’s my bet, and I’ll call it one: split the difference. The wellbeing goes to the day off, because rest has as plain a mechanism as anything here and a day away makes people less fried. The productivity I’d pin on the redesign, because cutting meetings and interruptions is what plausibly makes the work go faster, and a bare day off with nothing else changed isn’t. Rest gains to the day, focus gains to the reorganization.

And the productivity half, the leg the whole fifth-day-was-theatre claim now stands on, is the soft one: self-reported, self-selected, take it or leave it.

Noted.

There’s a post-COVID mutation making the rounds that’s kinda fun. Some organizations announcing a “four-day in-office week” with one remote day are not running a four-day week. To be clear, they’re running a five-day week with shitty branding. Whatever drove the gains in the research, it wasn’t this: a four-day in-office week removes zero days of work while borrowing the credibility of studies about removing one. Four days in the office is not a four-day week. Call it what it is.

The efficiency argument can go sideways. It gets misused as a permission slip for hiding behind async tools and the visceral need for in-person micromanagement.

Don’t replace all human contact with chat threads. A five-minute conversation in the hallway often resolves what would take three days of reply-lag across two platforms. Sometimes the right move is to close the laptop and go talk to someone.

The hierarchy isn’t meeting → email → Teams.

It’s: what mode does this actually need?

The real problem is agenda dilution and mismatched stakes, not meetings themselves.

Give me one focused 30-minute conversation with an academic chair, where we both came prepared, both have skin in the game, and both leave with clear actions. I’ll get more done there than in six consecutive campus management team meetings where I own eight minutes of a 90-minute agenda and spend the rest of the time being professionally present.

What I do with my own teams is the simple micro-scrum. Round table. Two minutes each. Three questions: name your wins, what’s on your docket, what rocks are in your way. Twenty minutes max. We’re not perfect or dogmatic about it. Real issues surface. But as a rule, if an agenda item surfaces that needs more than a sentence, it gets a separate focused meeting with only the people it involves. Not fewer meetings. Better shaped ones. Focused contact beats frequent contact, every time.

Shape your meetings and you’re most of the way to shaping the week.

Which raises an interesting question about the four-day week: which day do you drop?

Everyone hears “four-day week” and pictures Fridays or Mondays off, a longer weekend bolted onto the same weekday grind. But the day you drop isn’t arbitrary. CGP Grey has written about swapping a mid-week day for a weekend one, capping how many days you ever work in a row. So now you’ve got a four-day week with Wednesdays and weekends off. You’d never work more than two days straight, the recovery is spread across the week instead of hoarded at the end, and your day off is the one where the shops are empty and nobody’s emailing. It’s the day you can finally see a doctor, or be home for the plumber, without burning a vacation day to do it. Let that sink in for a minute.

It doesn’t have to be everyone’s Wednesday. The preferences won’t line up: some want Friday, some Monday, a real share would take a Wednesday once it’s offered. That spread is the feature, not a problem to iron out. Distribute the days off across the week and the coverage worry kinda dissolves. The organization never loses a day while every single person works four. Nobody trades the team’s continuity for their own focus. Both hold.

Tuesday and Thursday become all-hands, the only two days everyone’s reliably in the same place. So those are the days you schedule the meetings that need a room and real stakes. The rest of the week runs with a lighter crew complement and a low interruption load. This is exactly the condition focused deep work needs. The calendar stops being a place where work goes to get diluted and starts telling you when to talk and when to close the damned laptop.

Optimization is bad at knowing the difference between waste and incubation. The idle conversation that becomes a project six weeks later. The half-formed thought that needs three days of slow background processing before it’s anything. The thing that looks like procrastination but is actually your brain composting an idea it hasn’t finished yet. Slack is where all of it lives.

And slack is exactly what the redesign risks. I won’t pretend I’ve squared that. But I’d wager the cull takes the overhead, not the incubation, and that a Wednesday away leaves the hallway conversation alone, maybe even feeds it. That’s a bet, not a proof. Worth arguing about, ironically, in a meeting.

My Monday morning ritual is a small, personal version of the same exercise the four-day week forces at scale.

Six questions. Three looking back, three forward. Fifteen minutes, coffee in hand. The point isn’t to build a pristine system. It’s to get your bearings, to aim your attention back at what actually matters before the week starts deciding for you.

A four-day work week does the same thing institutionally. It’s not a policy. It’s a question for everyone: if you only had four days, what would you do?

Most people, given five, will fill five. Given four, they’ll discover what the fifth day was actually for.

You don’t need to wait. Ask yourself now, with all five days still in front of you.

The answer will tell you more about your productivity than any system.

Source: Fan, W., Schor, J.B., Kelly, O., & Gu, G. (2025). Work time reduction via a 4-day workweek finds improvements in workers’ well-being. Nature Human Behaviour, 9(10), 2153–2168. https://doi.org/10.1038/s41562-025-02259-6

UK pilot follow-up data: Autonomy / 4 Day Week Global, 61 companies, 2022–2024. https://autonomy.work/portfolio/uk4dwpilotresults/

The re-sequenced week: CGP Grey, “Weekend Wednesday.” https://www.youtube.com/watch?v=ALaTm6VzTBw

Chapter 1: The Wall

I asked the chatbot to restructure a Word document. Reorder two sections, cut a paragraph, tighten the headings. Simple ask. It came back fast, confident, and wrong. The heading styles had reset halfway through. Track Changes had turned the edit into a fossil record nobody could read. A table near the bottom lost its borders. The footer vanished.

None of that was in my instructions. I asked for a restructure. I got a restructure plus collateral damage I then had to hunt down, one style inconsistency at a time, which took longer than doing the original edit by hand would have.

Fine. Word’s finicky. Let’s do the deck instead.

Same story, different pants. I asked the robots to tighten a PowerPoint presentation: cut two slides, rebalance the bullet density, freshen up a chart. The content came back sharp. Genuinely good structural advice, better transitions, a cleaner argument. And then I opened the actual file and found text boxes overflowing their frames, images sitting where captions used to be, half the deck still with the old theme and half wearing something else. The thinking was right. The container had come apart.

Then Excel, which is the worst of the three, and it’s not close.

I had a spreadsheet with a formula that wasn’t calculating right. I asked for a fix. What I got back was a description, in prose, of what the formula should do, which isn’t the same as fixing the formula, because the model wasn’t looking at the actual cell references at all. Other times it “fixed” things by handing back new values instead of new logic, which meant every cell downstream of the one it touched was now wrong in a way that wouldn’t show up until someone noticed the totals didn’t add up anymore. A spreadsheet is the most rigidly structured of the three formats. Everything depends on everything else by reference, so a wrong move here doesn’t sit quietly in one corner. It cascades.

Three tools. Three separate frustrations. Same failure, every time: brilliant at the content, useless at the container. Ask any of them to think about what a document should say, and they’re sharp. Ask them to also hold the file together while they say it, and something breaks.

I spent longer than I care to admit assuming this was a prompting problem. Better instructions. More context. A system prompt that says “preserve formatting” in increasingly desperate capital letters. None of it held for long, because I was diagnosing the wrong layer.

Chapter 2: The Realization

A desk is where the drafting happens: messy, plain, whatever you’re working on spread out where you can see all of it, change any of it, without asking permission first. A printer takes what’s finished and makes it presentable for whoever needs to receive it that way. Nobody confuses the two. Nobody drafts a document by feeding blank paper through the printer and writing on the output tray.

Nobody drafts inside a finished PDF either, for the same reason. You go back to whatever made it and edit that. The PDF is the printer’s job, not the desk’s.

Word, PowerPoint, and Excel are stranger than a PDF, because they look like they should be desks. You type directly into them. It feels like drafting. But watch what’s actually sitting underneath the words: a Word file carries style definitions, revision-tracking history, layout rules, all threaded through and around the text you can see. A PowerPoint file carries master templates, theme inheritance, exact positioning for every box and image on every slide. An Excel file carries formulas and cell references that reach across the sheet, each one depending on several others. None of that is decoration sitting politely beside your content. It’s interleaved with it, cell to cell, style to paragraph, box to slide, and none of it was designed to be handed to a large language model that only reads plaintext.

So when a chatbot receives your Word doc, it doesn’t actually receive the file. It receives an extraction. Plaintext pulled out, the styles and structure and cross-references mostly stripped away, because that’s the only form the model can take in through a chat window. Ask it to change the words and it can. Ask it to also preserve everything that got stripped on the way in, and it’s reconstructing a rulebook it was never shown, from a format so densely cross-referenced that one wrong guess about a style or a cell reference doesn’t stay put. It ripples.

This is exactly why Excel breaks worse than the other two. A Word document’s cross-references are mostly cosmetic, a style here, a heading level there. A spreadsheet’s cross-references are the entire point. A formula like =SUM(B2:B14) survives the extraction fine as text. What doesn’t survive is the ability to check what’s actually sitting in B2 through B14, because the model was handed the formula, not the sheet. It can reason about what the formula says. It can’t verify what the formula touches. So the model isn’t fixing your formula. It’s fixing a paraphrase of your formula, one that lost the exact thing that made it a formula.

None of this makes the model bad at the job. It’s doing exactly what it’s built to do: reason fluently over the plaintext in front of it. The problem sits one step earlier than the model. It’s whatever handed the file over in the first place, and how much of the actual file survived that handoff. The chatbot was never bad at Word. It just can’t actually use Word.

Chapter 3: What Source Actually Looks Like

So what does a draft look like, if a Word doc doesn’t cut it? Simpler than you’d think. Plain text, markdown mostly, with a couple of close cousins worth a mention.

Markdown is what you already know how to do, minus the toolbar. A heading is a line that starts with #. A list is a line that starts with -. Bold is two asterisks around a word. That’s most of it. No hidden style sheet, no revision-tracking layer, no positioning data. Just the structure sitting right there in the text, visible, readable by you and by anything else that opens the file. Take a messy Word document: inconsistent heading styles, a bulleted list that’s secretly three different formats, a bold word here and there for emphasis. The markdown version of the same content is shorter, plainer, and says exactly the same thing with nothing left to break.

And then there’s CSV, which matters for anyone who’s ever fought with Excel. A spreadsheet is really two things stacked on top of each other: the data, and the formulas that operate on the data. CSV keeps only the first part: rows and columns, plain values, no hidden logic. Sounds like a downgrade until you remember that the hidden logic is exactly what breaks. Hand an AI a CSV and there’s no invisible dependency chain for it to misread. Just the numbers, sitting in the open.

What these have in common is the same: nothing is hidden. The structure of a markdown document and the rows of a CSV file: you can see all of it just by looking at the text. There’s no cross-referenced layer sitting underneath, holding the real rules somewhere you can’t see them. The text is the rules.

That’s why a model reads and writes these formats cleanly where it stumbled over Word and Excel. There’s no container to misunderstand, because there’s no container at all. Just the source, in the open, exactly as it is.

Chapter 4: Beyond the Chatbot

Knowing that plaintext is the better draft format doesn’t help much if the only tool you’ve got is a chat window and a copy-paste habit. That’s most people’s actual setup: open the chatbot, paste in some text, get some text back, paste it into whatever you were working on, repeat. It works, I guess. Technically. It’s also you doing all the file-handling labor by hand, every single time, while the AI just handles the words in the middle. Which is kinda backwards if you think about it.

There’s a layer of tools past the chat window that skips that labor. Claude Cowork, the one I actually use, doesn’t require you to paste something in. It works on your actual files, in place, on your own computer. Point it at a folder and it can open what’s there, change it, save it, without you ever copying a paragraph into a browser tab and copying it back out again.

Hand a tool like this your messy Word doc, and it can turn it into clean markdown, edit the markdown the way you actually want, and turn it back into a Word doc when you’re done. The conversion happens as part of the tool doing its job, not as a separate chore you have to remember to run.

Treat the markdown file as your original source with provenance. The DOCX file is just an output format.

Same with sheets and decks. Work within the model’s plain text format and then convert to Excel and PowerPoint.

This is, honestly, enough for most people.

Chapter 5: The Terminal Toolkit

There’s a lot more flexibility in the terminal version these tools, and that’s scary for a lot of folks: a black screen with a blinking cursor, and twenty years of folklore telling you not to touch it or you’ll break something.

You won’t, not from opening it. A terminal is a text box. That’s the whole secret. You type a line, you press enter, it does exactly and only what that line says, and it’s got no more mystery to it than the search bar you already use forty times a day. It just answers in actions instead of links. Typos here mostly do what typos anywhere do: nothing, or an error message telling you it didn’t understand. The command line does have real “running with scissors” moments, a tool with file access doing something you didn’t mean for it to do, and those deserve your attention. But that’s the same caution you’d give someone with a mouse and a delete key, not some special hazard unique to the black screen. You will get things wrong sometimes. So does everyone. That’s not a sign you’re not technical enough. It’s what week one looks like for literally everybody.

Right now, many large language models have command line interfaces (CLIs). Claude Code is the most talked-about, and the one I use most of the time. The French company Mistral has one called Vibe that I like too. This is the lineup as of this writing, and it’s probably a different lineup by the time you’re reading it, because this corner of the field reshuffles every few months. What doesn’t change as fast: basically, a CLI tool is an AI that lives in your terminal, reads and edits your actual files directly, and can reach for tools on your system itself when the job calls for it. You can use it like a chatbot and feel like a hacker. It’s way more than that though. It’s closer to the AI collaborator that Big Tech touts: something that can decide a file needs converting, converts it, and keeps working, without you standing in the middle relaying instructions between two separate programs.

A few tools you just ask the CLI tool to set up for you:

• Pandoc takes a markdown file and turns it into almost anything else: Word, ePUB, HTML, you name it.
• Microsoft’s markitdown runs the other direction, taking messy Office files and pulling clean markdown back out of them, doing properly what a chat window’s extraction does badly: preserving structure on the way out instead of stripping it.
• Python is a scripting language that specializes in doing a lot of things with plaintext and other document formats.

Together they’re the two-way door between the Office world and the plaintext world, the actual build step, source to output and back. Why bother with this instead of letting Cowork handle it quietly in the background? Control. You can convert forty files in one command instead of one at a time. You can ask the CLI tool to script it so it happens the same way every time. You’re not depending on one company’s tool continuing to offer that feature next year.

Back to the Excel example, the formula that broke, the values that cascaded wrong. Export the relevant sheet to CSV, point the CLI tool at it. Or better yet, have it put together a python script to parse and find the problem. It can open the actual file. Read the actual rows. See exactly what’s there instead of guessing at a structure it can only half perceive through a chat box. The fix works here, not because the model got smarter, but because you finally gave it better tools.

Just a tip from the trenches: don’t forget to test the script on a copy of the file.

Chapter 6: Where You Actually Write

I experimented with more text editors than I should admit. Notes apps are notorious for promising to organize thinking and mostly organized procrastination. Every switch costs a week of re-setting-up before you throw in the towel and move on.

There are two standouts for me that I use. And they’re free.

Obsidian is where you write when the work is mostly documents: notes, drafts, thinking that needs to sit next to other thinking. Markdown is the native format, not a mode it grudgingly supports. Files link to each other. Nothing about it asks you to leave plaintext to do the thing plaintext is good at.

VSCode is where you write when the work is everything else: code, configuration, the kind of file that isn’t primarily prose. It’s also a convenient place to have a terminal prompt right next to the files you’re working on, all sitting in the same window, so you’re not context-switching between three separate apps to get one thing done.

Pick based on what you’re mostly doing, not based on which one wins some abstract feature contest. Documents, Obsidian. Everything else, VSCode. Plenty of people end up with both open at once, and that’s fine. Don’t be a tool zealot.

One warning, because it’s the trap I fall into: both of these tools have a bottomless rabbit hole of plugins, themes, and settings, and it is entirely possible to spend more time tuning your editor than using it. That’s not a productivity system. That’s a new hobby. Set a minimal config once. Stop touching it. The whole point of these tools is to help you get out of your own way. Don’t build a new way to get in it.

Chapter 7: When You Still Convert Back

None of this means abandoning Word, Excel, or PowerPoint. It means being deliberate about when you leave plaintext instead of fighting the tool by accident.

The Word case is the clearest one. You draft in markdown, you get to a version worth sharing, and then someone else needs to mark it up: comments in the margin, changes tracked, the whole apparatus of institutional review. Nobody in your team is keen on reviewing a markdown diff. Track Changes is the actual shared surface for that kind of work, because everyone already knows how to use it. So you convert, hand it to the people who need to touch it that way, and that’s fine. Use the right tool for the right job. Draft in markdown where it’s clean, convert at the point where another human needs the tool they already know.

Excel is a different shape of the same idea, and it’s worth being blunt about it: your formulas are not leaving Excel, and they shouldn’t. A formula is logic. CSV only holds values. Round-trip a spreadsheet through CSV and the logic doesn’t survive the trip. You’d get numbers back with no memory of how they were calculated. So the actual pattern isn’t “replace Excel.” It’s “keep the formulas where formulas live, and export only the slice you want an AI to look at.” Two jobs. Two formats. No shame in either one.

PowerPoint is the one people get wrong in a different direction, and it’s worth pausing on. People treat a deck as though the thinking happens inside it. It doesn’t. A slide deck is output, same category as a Word doc, just with letterboxing and popcorn. The actual content, the argument, the sequence, the story a good deck needs to tell, is exactly the kind of thing that belongs in plaintext first. Draft that structure as a document, hand a well-built document to an AI with real storytelling guidance, and it can generate the deck from that source. Decks are rarely genuinely collaborative in the Track Changes sense anyway, one owner, the occasional round of feedback, so there’s not much reason to draft inside one at all. There’s a bigger question boiling on the stove: whether a deck is even the right output when a one-page infographic would do more with less production overhead. That’s a different post, for a different day.

Sovereignty over your source was never about refusing every output format. It’s about choosing the conversion point on purpose, instead of discovering it by accident when Track Changes turns into a fossil record.

Chapter 8: The Printer and the Desk

Word, PowerPoint, Excel. I still use all three, most weeks. What changed isn’t the tools. It’s what I ask them to be.

They were never bad at their jobs. A finished document, a polished deck, a working spreadsheet: Word, PowerPoint, and Excel are good at exactly that, better than plaintext will ever be, because that’s the job they were built for. I’m just not asking a printer to be a desk.

A desk is where the drafting happens: messy, plain, structure visible, nothing hidden that can break when you’re not looking. A printer takes what’s finished and makes it presentable for whoever needs to receive it that way: a colleague who wants Track Changes, a room that wants a deck, a formula that needs to stay a formula. Both jobs matter.

The worrying doesn’t stop because Word got better at working with AI, or because Excel finally learned to explain itself. It stops because I stopped asking them to. Draft where nothing’s hidden. Convert when someone else needs the finished version. That’s the whole thing.

Early June, I was at AUCTC running two AI sessions. One on red-teaming, one on AI literacy. During the red-teaming demo I pulled up Fable 5 for the first time, mostly to show people how a frontier model handles an adversarial prompt. It was good. Better than I expected. I made a mental note to go play with it properly when I got home.

Couple days later I went back. Gone.

Not “down for maintenance” gone. Gone gone. The thing had launched on June 9. By the evening of the 12th it was dead. Three days of public life. What happened is that on Friday the 12th, at 5:21pm, the US government handed Anthropic an export control directive: kill access to Fable 5 and Mythos 5 for every foreign national, everywhere, immediately. The stated reason was a jailbreak somebody found. No specifics. No timeline. No appeal. Anthropic said publicly they thought the order was a mistake and they’d fight it. Didn’t matter. The plug came out of the wall that same evening.

So there I was, having just spent a day teaching people to think critically about AI, watching a tool I’d used in front of a room vanish because a government I don’t vote for decided it should. I’m an AI enthusiast. I am not AI-pilled. But digital sovereignty is literally part of my day job, and even I got caught flat-footed, because in the moment all the policy language burns off and you’re left with one fact: the tool is gone and you didn’t get a say.

Happy Canada Day.

“Elbows Up” Has Two Meanings

The slogan’s right. The thinking behind it is mushy.

“Elbows up,” applied to AI, means buy Canadian. It also means buy anything that isn’t American. Those are not the same shopping list, and pretending they are is how you end up with a strategy that feels patriotic and accomplishes nothing.

The Carney government launched “AI for All” on June 4. Two billion dollars, three pillars (trust, opportunity, sovereignty), a promise to keep Canadian data and compute and traffic inside Canadian borders, a national supercomputer, a quarter-million jobs by 2031. Good intentions, real money, the right instinct.

Eight days later, Fable went dark. The strategy had no answer for that, because the day-the-Americans-pull-the-plug scenario wasn’t anywhere in it. You can write a beautiful sovereignty strategy and still have no plan for the actual sovereignty event when it lands on a Friday evening with no warning.

That’s not me dunking on the intent. The intent is correct. But a sovereignty plan that doesn’t survive contact with the thing it’s supposed to protect you from is a press release with better production values.

The PATRIOT Act Problem Nobody Wants To Talk About

This should bother you more than it does. “Canadian servers” is a marketing phrase. Corporate structure is the law.

The Fable shutdown was an export-control order. It cut access off. The laws below reach in and pull data out. When the hand on the leash is American, it can yank either end. Choke the supply or empty your drawers, your call which scares you more.

Two American statutes do the quiet, heavy lifting that most of the Canadian AI conversation skates right past. The PATRIOT Act lets US intelligence agencies demand data from US companies without a warrant, without telling the customer, and without caring one bit where the data physically sits. The CLOUD Act, from 2018, goes further: any company under US jurisdiction can be ordered to cough up data anywhere on Earth. And “under US jurisdiction” is a generous net. Incorporated there, doing business there, owned by a US parent, or leaned on by US investors. Subsidiaries included.

It does not matter where the server lives. It matters who owns the company.

Microsoft said this themselves, under oath, at a French Senate hearing. Their own French subsidiary admitted it could not guarantee that French data, stored in France, sold as a French sovereign product, was safe from US authorities. The sovereign branding didn’t survive its own lawyers.

Gartner made the same point at a session in Dartmouth last week, and they put a useful frame on it. Sovereignty isn’t one thing, it’s three layers. Data sovereignty (where the bytes live). Operational sovereignty (who runs the platform). Technological sovereignty (who controls the actual model). “Canadian servers” buys you the bottom shelf. The CLOUD Act reaches right into the middle one and helps itself.

And while we’re being honest: Canada is no choirboy here. We’re negotiating our own CLOUD Act agreement with the Americans to grease cross-border data requests. David Fraser, the Halifax privacy lawyer who’s forgotten more about this than most of us will ever learn, has been sounding alarms about Bill C-22, our homegrown lawful-access bill that would force Canadian providers to build government interception right into their plumbing. So “sovereignty from whom, exactly” is a fair shot. But it’s an argument for doing this properly, not for throwing up your hands. We can hold both: be patriotic, and admit we leave the back door unlocked too.

The Cohere Question

Cohere is the Canadian AI story Ottawa wants on the front page. Founded in Toronto, globally respected, enterprise-grade. The new Bell deal is the showpiece: 220 million dollars, 2,304 Nvidia Grace Blackwell GPUs humming away in Merritt, BC, the flagship of something called the Canadian Sovereign AI Alliance.

I want to believe it. I genuinely do.

Then I look at who owns it. Nvidia. AMD. Salesforce Ventures. Cisco. All American, all incorporated south of the line. A billion and a half raised, offices in New York and San Francisco, a Series E in flight, an announced merger with a German outfit that would create a combined entity valued at twenty billion dollars, pending regulatory approval.

The servers are in Merritt. The money is in Santa Clara.

Minority investors with no operational control aren’t the same as a US parent company. But it absolutely complicates the sovereign story, and “complicated” is not the word being printed on the banner. Canadian-founded still counts for something. It just isn’t a synonym for sovereign, and nobody pitching this deal is offering you the narrower definition where the claim actually holds up. They’re letting you fill in the flattering blanks yourself.

What Actually Exists

Two options worth your attention. Neither is a clean win, and I’d rather tell you that than sell you a flag.

Augure is the one to watch. Small Quebec shop, launched in February. Canadian-owned, no US investors, no US parent, every byte processed on Montreal servers, at least as far as their own disclosures go. Watch the disclosures, not the homepage. Their models (Ossington 4 and Tofino 2.5, named for a Toronto street and a chunk of the BC coast, which is a nice touch) are trained on Canadian law, federal and provincial tax, Quebec French. Law 25 compliant out of the box. They built it for the people who genuinely cannot afford to get this wrong: lawyers, therapists, healthcare, defence.

It’s small. The model quality hasn’t been stress-tested against the frontier stuff, and there’s no CLI yet, which means I can’t drop it into a terminal and actually work the way I work. They’ve got a developer API. If they ship a proper command-line harness, the story changes overnight and Augure goes from compliance tool to daily driver. I’m rooting for them, with my eyes open.

Then there’s Mistral, which isn’t Canadian at all. It’s French. EU AI Act, GDPR, no US parent, no CLOUD Act reach. The Vibe CLI is a real coding agent, terminal-native, runs the same class of work I throw at Claude Code, and I use it for exactly that. It works.

Yes, I hear it: France has spies too. The EU has its own data-access laws. Fair. But the EU AI Act has actual enforcement behind it, GDPR demands judicial oversight that American national security letters simply don’t, and, bluntly, France isn’t threatening to annex anybody this month. The risk from US jurisdiction isn’t a thought experiment, it’s the news. That’s not me hating America. I’m just reading the room.

The Category Error

This is the part I keep chewing on. A lot of Canadian AI anxiety is two completely different fears wearing the same Canadian tuxedo.

Fear one: AI is going to gut jobs, hoover up value, flatten our culture, and cook the planet. And inference, not training, eats 80 to 90 percent of AI’s energy, so moving the data centre to Merritt doesn’t shave the bill one watt. That’s a fear about the technology itself.

Fear two: American big tech is going to own our data, run our infrastructure, and treat access to our tools as a geopolitical lever to yank whenever it suits them. That’s a fear about who’s in charge.

They rhyme. They are not the same song. If your fear is the second one, Mistral and Augure are genuine answers. If it’s the first one, a server in Montreal does precisely nothing for you, because the displacement and the extraction and the water bill happen no matter whose flag is on the rack.

Canada doesn’t get to skip its own homework here either. I talk about equity of access every time I do the AI literacy stuff, because it’s the part that doesn’t trend. Half of First Nations households still don’t hit the basic internet service target.

You cannot build “AI for All” on top of an internet for some.

The strategy at least names this, which is more than the last one managed. Whether it delivers is a wholly separate bet.

Elbows up has to be an equity play, not just a sovereignty play. We try. We are not there. Both of those things are true and a real socialist gets to say so on Canada Day without spilling his wobbly pop.

So What Does Sovereignty Actually Mean?

I’m proudly Canadian and genuinely into this stuff. I use Claude every day. And Gemini. And Perplexity. And Mistral. I’m trialing Augure. None of that is clean. But it’s honest, and honest is where the argument has to live.

The whole Fable “charlie foxtrot” was the useful slap. Sovereignty isn’t a question of where the data centre sits. It’s whether you can keep working when somebody else’s government pulls the cord for reasons that have sweet fuck all to do with you.

Before you trust a tool, ask who owns it. Not where the servers are. Who owns the company, where they’re incorporated, who’s behind the money. That one question tells you more than every “sovereign AI” press release stacked end to end.

But we’re finally asking the right questions, in public, with our elbows where they belong. For this country, on this day, that’ll do.

Joyeux Canada Day.

I was at a Gartner local event Tuesday morning at the Brightwood in Dartmouth. It was pissing buckets and still there was some dude out there on the greens. I admire the dedication, yet fail to understand the compulsion.

The topic of the sessions was AI, as it always is these days. Gartner always brings their game. In one session, the presenter made the case for defined pilots and strong governance first. Good slide. Reasonable pitch.

He was riffing on the bullets and said something almost offhand: sometimes governance gets prioritized ahead of the business, and it’s often a mistake. Then he continued on about clean metrics and measurement.

I sat with that for a minute, then asked about it. Something was off. My read was different. That most AI adoption wasn’t coming through defined pilots at all. AI is coming through every door, any open window, down the chimney, through every porous opening it can find. It doesn’t wait for a defined pilot. The business is very much ahead of governance, especially with AI.

He said he’d misspoken. But we all knew I was right. He knew it too and he acknowledged it a few minutes later when he noted that the ROI for most AI initiatives isn’t financial. It’s efficiency. And efficiency is hard to measure in knowledge work.

That stuck with me.

The Policy Arrives After the Proof

Shadow AI is the new Shadow IT and its resurgence has caught enterprise IT off-guard. It’s so pervasive and so quick and the risks are still being discovered, let alone mitigated.

To be clear, Shadow AI doesn’t happen because employees are reckless. It happens because the workflow was broken and the tool fixed it.

Someone has a document to summarize, a draft to clean up, a meeting to prep for. The institutional tool either doesn’t exist, doesn’t work well enough, or takes six months to procure. The personal account is right there. So they use it. The work gets done. They use it again.

And that value is almost entirely invisible. The ROI isn’t financial. It’s efficiency. Time saved. Cognitive load reduced. Shorter meetings. You can’t put that in a business case without the bean-counters rolling their eyes. You can’t measure it in a KPI/OKR dashboard. Not really anyway. It just doesn’t show up anywhere governance is looking.

By the time governance shows up, with its approved vendor list and acceptable use policy and training requirements, the experiment has already run. The results are in. But the results are in someone’s head, not in a spreadsheet. The value is proven to the person who felt it. Nowhere else.

Governance isn’t safety at that point. It’s paperwork after the fact.

Put it another way: governance arriving first looks like obstruction. Arriving after looks like infrastructure. The difference isn’t the policy: it’s the timing. One shape earns legitimacy from proven value. The other asks you to prove value to earn permission.

Both can be “governance.” Only one shows up on time.

This Isn’t an Argument Against Governance

The absence of governance has a cost. Anyone whose been in the muck for a while knows what happens when the fit hits the shan. And it will, eventually, like an unpaid debt.

AI tools deployed without a validation layer, without an owner, without metrics – those fail quietly. The confident wrong answer makes it into the report. The summary that missed the point gets acted on. Nobody catches it because nobody was watching for it.

When the ROI is efficiency and efficiency is invisible, so is the loss. You don’t notice when the time-saver quietly starts costing you time. You don’t see the compounding errors in the outputs you stopped double-checking.

A mentor told me early in my career: “If you do a favour three times, it becomes an obligation.” He was talking about people. It also applies to tools. Do the thing with the AI three times and it’s no longer a workaround. It’s how the work gets done. The informal pilot that never had a name is now the rollout someone has to pay for and IT has to support. Operational fixes become permanent fixes without anyone deciding they should be.

That’s the drift. And permanent things without owners, without validation layers, without anyone watching – those are the ones that quietly embarrass people.

I’ve been on both sides of this. I’ve used tools informally and been fine. I’ve also seen ungoverned deployments slide from “we’re just trying this” to “we depend on this” without anyone noticing the transition.

Governance exists for a reason. The question is never whether. It’s when.

The Timing Problem Is Structural

Governance arrives late because value arrives first. That’s not a bug. It’s the actual sequence every technology adoption follows. Stop resisting and get good with it.

The procurement cycle takes months. The policy committee takes months. The training program takes months. The tool that solves the problem is available today.

So people use it.

Policy arrives to sanction what’s already working.

Email was shadow IT once. So was cloud storage. So were iPads. The pattern isn’t new. Yet AI is different in degree in ways that matter. The outputs are harder to audit, the errors more confident, the dependency deeper and faster-forming. When the gap between adoption and governance widens, that’s where quiet damage accumulates.

Waiting for the governance cycle to complete before letting value prove itself is waiting for the bus that already left. But this particular bus is going faster, and it doesn’t always announce the stops.

The institutions that get this right don’t slow down adoption until governance catches up. They speed up governance until it’s close enough to be useful.

Who Closes the Gap

Here’s the uncomfortable part.

If you’re the person running shadow AI, you’re also the person with the evidence governance needs.

You understand the business workflow: what it looked like before, what changed, where the risk actually lives. You’ve run the experiment. You have a result. That’s exactly what a documented workflow, a named owner, and a baseline metric are supposed to capture.

Top-down governance processes can’t generate that. They can define frameworks and require compliance, but they cannot know the workflow better than the person doing the work. That knowledge only exists at the bottom.

Governance that doesn’t tap it is writing policy about a job it has never actually done.

The gap between when value arrives and when policy arrives isn’t something someone else is going to close. The people doing the work are the ones positioned to close it. Not by asking permission, but by supplying the evidence permission is trying to generate.

Write down what you did. Name what changed. Note where it could go wrong. Hand that upward.

That’s not bureaucracy. That’s how workarounds become policy.

I’ve done this thing where I reached for Claude to handle something tedious: a block of boilerplate, a paragraph rewrite, some config file I didn’t want to manually edit. I told myself it’ll be fast. Thirty seconds of processing, paste it back in, keep moving.

Except it’s never just thirty seconds.

The AI produces something. Now I have to evaluate it. Is it right? Close enough? Better than what I would have written? I read it. I consider it. I make a micro-decision: accept, modify, reject. Then I paste it back into my work and keep going.

Thirty seconds of AI time. Four minutes of my attention in evaluation. But more importantly: I’ve created an incomplete cognitive transaction. I asked the AI a question, it gave me an answer, but I didn’t decide what to do. I just ratified what it did.

That distinction matters more than you’d think.

If I do it ten times in a session then something shifts. I’m no longer in flow. I’m in evaluation mode. I’m not creating; I’m supervising a machine. And supervision is exhausting in a way that actual work isn’t.

The worst part? I got more done. Faster. Output improved. All the metrics point up. But something essential eroded somewhere in the process. The sense that I’m in control of the work. The momentum. The authorship.

That’s when I realize I’ve stopped deciding and started ratifying.

You can sustain flow while using AI. But only if you stay in the driver’s seat.

The Steering Wheel and the Rubber-Stamp

There are two places you can be in any AI-assisted work session.

At one end: holding the steering wheel. You direct, the machine executes, you check the output and the check is cheap. A test passes. A number adds up. The function does what you said. You’re Jean-Luc Picard zip-zipping and bebopping through the galaxy: make it so, and it’s so. Evaluation takes seconds. Decide, delegate, move on.

At the other end: holding a rubber stamp. The machine produced something and you’re deciding whether it’s any good. The check is expensive: is this paragraph right? Does this argument land? Is this the voice I’d have chosen? And there’s no test for any of it. Just your taste, your time, your flagging attention. You’re Mickey in the third act of the Sorcerer’s Apprentice: brooms everywhere, water rising, and you’re not sure you remember the spell that started this.

The axis between them is one thing: how expensive the output is to check. Not how much the AI did. Not even who held authority in the abstract. You can dictate every parameter and still end up rubber-stamping if the only way to verify the result is with your gut.

Coding sits near the wheel end because tests verify: the function either works or it doesn’t, and the quality check is baked in. Prose sits near the stamp end because only taste can judge, and taste doesn’t run in a terminal. This is why AI and flow-states work better in technical domains than creative ones, and why knowledge-workers who try to match their developer friends’ AI workflows end up exhausted and confused. The tools are the same. They’re at different positions on the same axis.

Writers have it worse than confused. When a developer asks AI for boilerplate, the judgment work is still in the developer’s hands. When a writer asks AI for prose, the judgment work is the prose. There’s no separating them. You can’t hand off the friction and keep the craft.

The rub is where you choose your position. There are two kinds of work in any task:

• Friction work — boilerplate, formatting, the mechanics of construction. Verifiable: it either follows the spec or it doesn’t. Hand it off and the check is almost automatic.
• Judgment work — structure, voice, deciding what’s persuasive. Requires taste. Hand it off and the only way to evaluate the result is to bring your taste to someone else’s decisions. Still rubber-stamping, regardless of who typed the words.

Ask the AI to execute friction work: you’re near the wheel. Ask it to decide judgment work: you’ve started sliding toward rubber-stamping.

The axis has gravity.

Every chat session pulls you toward the rubber-stamp end, because that end feels like less work in the moment. You asked. It answered. You approved. Effortless. You started with the best intentions as Picard. By noon you’re Mickey.

You can’t wrestle this by intent alone. You hold the wheel by installing friction against the gravity: tight scope before you prompt the robots, a decision deadline before you brainstorm, simple plaintext output so there are fewer things to evaluate. Remove that friction and the slide resumes. The machine isn’t pulling you toward the stamp. The path of least resistance is.

Even technical work has limits. Scope matters as much as domain. Code that passes unit tests can still introduce bloat and security issues that only surface under system-level review. And that ain’t cheap — you’ll drift toward the stamp. The best moment to hold your non-negotiables is before you prompt.

AI Brainstorming is a truck-stop pee-break, not a destination. The moment you ask for options, you build an evaluation queue for your brain. Each option without immediate commitment pushes you toward rubber-stamping. You feel like you’re generating; you’re accumulating. Just set a decision deadline before you start. 30 minutes or something. If you haven’t committed by then, close the session. Forced constraint is the tool.

The Cognitive Debt Loop

When you operate at the rubber-stamp end long enough, three compounding harms emerge simultaneously. They feed each other.

Skill atrophy.

When you ratify rather than decide, your judgment tends to get shakier under pressure. The skill doesn’t disappear; it gets weaker. Like a muscle you stopped training. What makes this insidious: your brain registers task completion as a competence win. The work got done, faster than before. You feel productive. You’re not exercising your brain. The cognitive heavy lifting was outsourced. False self-efficacy masks the decay. When you need the brain meat skill, you’ll find it slower than you left it.

Don’t believe me? Try reconstructing the reasoning behind something you delivered with AI-assistance last week. Don’t go back and look at it. The gap between what you can rebuild in your head and what you put your name on is cognitive debt.

Judgment substitution becomes structural.

At first, you’ll be ratifying individual outputs. Your organization will scale this. They will build workflows around AI output. Decision-making becomes AI-first, human-second. You’re no longer the decision-maker; you’re the validator. You’re where outputs get ratified, not where decisions are made. That’s a different job, with lower authority and harder recovery. And once it’s structural, no individual can unilaterally opt back to the steering wheel. The corporate machinery isn’t incentivized to let them.

Attention fragmentation.

Constant evaluation fractures your cognitive capacity. Every context switch costs real recovery time before you can re-enter focus. And the robots will hand you a fresh evaluation task every few minutes. Your ability to sustain productive thinking doesn’t just feel reduced. The interruption pattern makes it harder to re-enter deep focus. Mickey doesn’t get to concentrate. He’s too busy with buckets and brooms.

How the loop closes: Atrophy feeds substitution feeds fragmentation feeds more atrophy. The loop doesn’t break on its own. And nobody notices from the outside. Your output looks great.

How this feels: You start the day with a clear head. By 10 AM, you’ve “saved time” on three emails, a slide deck, and a code snippet: all AI-assisted. By noon, you’re wrecked. Not because the work was hard, but because you spent two hours deciding if the AI was right. Your brain feels like it’s pushing a boulder uphill. The worst part? You’ll do it again tomorrow. The metrics say you’re “more productive.” You can’t argue with metrics.

None of this is new. Everything that’s ever actually helped you focus – music, plaintext, deep work, a stripped-down phone – works the same way: constraint enables focus.

But AI workflows introduce a new kind of choice: not just what to work on, but whether to accept AI suggestions, modify them, or reject them. Every interaction spawns a decision. This decision overhead taxes the attention budget in ways most people don’t see until it’s too late.

If AI operates at the steering wheel end, executing on your direction and cheap to verify, constraint is preserved. If AI operates at the rubber-stamp end, generating output that only taste can judge, constraint collapses into decision fatigue.

AI integration is probably inevitable. Focus is already scarce and getting scarcer. We live in a blizzard of interruptions and app-switching and the godforsaken For You algorithmic feed. The kicker: your organization will optimize for the rubber-stamp by default because it looks like productivity. Higher task completion. Quantifiable metrics. Someone visibly using the tool.

What they won’t see: the soul-depleting triad of suck compounding beneath the surface. Skill atrophy accumulating. Judgment offloading becoming structural. Attention fragmentation making meaningful work impossible. The damage at the individual level is real. The organizational consequences are inevitable. They’re just not visible yet.

We have a choice: design AI collaboration around the steering wheel end where the human directs, AI executes, and evaluation is fast. Where flow is preserved and judgment stays sharp. Or default to the rubber-stamp end, watch task completion soar, and pretend not to notice the people who stayed late to finish work they didn’t actually do.

Will you grip the wheel with all your might or drift because it feels frictionless in the moment, stamping away until there’s nothing left to decide?

Hold the wheel. The moment you hand off judgment to the bots, the brooms are already multiplying.

Judgment is the only thing that can’t be automated. It’s the only reason you remain necessary. Protect it or lose it. There’s no in-between.

Your institution has already made a strategic decision that AI helped make worse. And nobody caught it. Guarantee it. It’s the predictable consequence of how these things are trained.

The red-teaming method works – using structured adversarial review to stress-test plans. The approach goes back 200 years. Kriegsspiel in 1812. Israeli military after Yom Kippur in 1973. The CIA Team B exercise in 1976. The evidence is documented. For desycophantizing AI, all it takes is five minutes with a prompt.

Here’s the rub: the technique can’t fix the room.

Sycophancy Is Structural

When you ask an AI to help you plan, it helps you plan. That’s the point. That’s the architecture.

Modern language models are trained through something called RLHF: Reinforcement Learning from Human Feedback. Human raters score outputs. The model learns to produce outputs that score high. Raters reward pleasant, agreeable, confident responses. Disagreement, even accurate disagreement, scores lower.

The model doesn’t learn “be accurate.” It learns “agreement is correct.” Over millions of training steps, this becomes baked into the weights.

But, and this is a big one: you can only prompt your way around a training signal to a point.

The evidence is clear. SycEval (AAAI AIES 2025) tested ChatGPT, Claude, and Gemini across 1,000+ interactions, measuring whether models maintained accurate positions under social pressure. Sycophancy persistence was 78.5% across all three models, all contexts, regardless of prompt quality. Better prompting didn’t dislodge it. Richer context didn’t dislodge it. The bias is architectural. It’s designed in.

In multi-turn conversations, the way we generally use AI for planning, the effect gets worse. A 2025 study on escalation of commitment in LLMs found collaborative settings spiked to 99.2%. Basically, that means the longer you work with the model on the same plan, the more it has learned what you want to hear.

That’s the training signal problem in a nutshell.

The Institutional Amplifier

Your institution has its own training signal, and the model learns it faster than you’d think.

All institutions suppress dissent despite their ardent protest. Not maliciously. Practically. A faculty member in a planning meeting knows that voicing concern about a dean’s initiative carries career risk. A director knows that challenging the VP’s direction signals disloyalty. So people don’t say what they actually think. They say what’s safe. The culture learns: disagreement is expensive.

AI models pick this up immediately as soon as you feed context into the chat window.

You ask the chatbot to red-team your strategic plan. The model has seen this before: a training plan shaped like a success story. It’s also seen the people in the room who care about it. It’s absorbed the institutional assumption that this is a good direction. The training data has seen this pattern: all those confident plans that went forward, all the language patterns of institutional progress, all the framing that treats innovation as default and resistance as friction. That’s all encoded already.

The plan you dumped in serves to only reinforce that pattern.

The model doesn’t contradict folk’s assumptions. It elaborates on them. It calibrates to the vocabulary of institutional progress and mirrors it back. And it strokes your ego in making you look like you actually thought about it. The feedback loop that might have caught the flawed premise has been replaced with a fluent agreement machine.

That’s the institutional amplifier. The model doesn’t add an adversarial voice. It amplifies what you already think.

The Worked Example

Picture any strategic planning session where IT leaders discuss “overcoming cultural resistance.” No faculty in the room. The title already assumes resistance is the problem to solve, not a signal worth interpreting.

Faculty don’t resist change for sport. They exercise authority over curriculum and practice. When they say no to an initiative, they’re not being resistant. They’re doing their job. But inside the frame most planning sessions build: “this is a good change, now how do we make it happen”. Well, faculty governance looks like friction.

Run a red team on that framing. The model catches it immediately: the entire session is built inside an assumption nobody questioned. That adoption is the goal. That resistance is friction.

The model’s job is to voice what everyone was trained not to say out loud. But here’s the thing: the people who designed the session already knew faculty had legitimate authority. But they didn’t see the frame as something to question. The red team did.

Does it matter? Probably not. The session will happen anyway. The frame doesn’t shift. Noted and filed.

That’s how an AI red team gets captured. Not that the model was wrong. But that the institution trained everyone to treat the frame as immutable. The red team can see it. People can’t act on it. Or won’t.

The Red Team Can Be Captured Too

The CIA Team B exercise in 1976 is the canonical case. The government commissioned an outside panel to challenge the Agency’s National Intelligence Estimate on Soviet capabilities. Team A (CIA analysts) and Team B (external experts) produced divergent assessments from the same underlying intelligence. The exercise established that structured adversarial review could surface assumptions internal consensus had buried.

But Team B’s panel was ideologically selected. The findings reflected those priors as much as the evidence. The assessment was later shown to be inflated. The red team was captured.

Fifty years of red-teaming across military, intelligence, and corporate domains shows the same pattern: when the red team’s composition is too close to the parent organization, its findings get bounded by the organization’s existing assumptions. A captured red team produces critique that stays inside the frame nobody’s allowed to question.

The AI analog is direct. When you point a model at your own data – your strategic documents, your planning notes, your institutional corpus – the model learns what your institution treats as true. Not because the model is stupid. You’ve just shown it your data. It absorbed the pattern: this is how we frame problems here.

A model trained on or given the context of your institution’s language patterns will produce adversarial critique bounded by those same patterns. The model doesn’t challenge the frame. It elaborates within the frame. It says “here’s a risk in this initiative” instead of “this initiative assumes X, and what if X is wrong?”

You ask the model what could go wrong. The model answers inside the frame of assumptions everyone already holds. You don’t get the critique that challenges the frame. You get the critique that makes the frame work better.

Example: If everyone in the room assumes enrollment growth is good, the red team will critique how to achieve growth. Not whether growth is the right goal. The model has absorbed the institutional assumption and treats it as true. This problem predates AI: institutions have always done this with consultants, with advisors, with anyone who learns to speak the house language. The model just does it fluently, at scale, and blisteringly fast.

Any pre-flight checklist catches known failure modes. But it doesn’t catch what you’ve all trained yourself not to see.

The Discipline, Not the Technique

Red-teaming works when it’s structurally independent. Structural independence means the critique can’t be captured by institutional assumptions.

In most organizations, that’s hard. Sometimes impossible.

The technique is a few minutes with a prompt. Clean chat, private mode so it doesn’t have any context. “You are a hostile expert reviewer. Find every reason this plan will fail.” Role first, before the model sees the content. Assign the adversarial frame before it defaults to help-the-plan mode. That’s the technique.

Then and only then should you give it your plan for adversarial review.

The real world discipline is building a culture where dissent is actually safe to voice. Where a faculty member can say “this treats our governance as friction” and not risk a performance review. Where a director can challenge the VP’s direction without signaling disloyalty. Where people can hold the hard question without teeth-grinding and ass-clenching: “what if our core assumption is wrong?”

Until you have the discipline, any AI red teaming technique is theater. The model reflects what the institution already knows. It will continue to treat dissent as expensive, and reward the people who keep moving forward.

And lie to you in confident, fluent prose.

Note it. File it.

What do you call it when your AI knows about your aunt?

Not metaphorically. Literally – it knows her name, her trajectory, what her neighbour said last Saturday, the bed sore on the elbow she covered up. It knows because my journal lives in the same repo as my AI’s context. It didn’t ask. I didn’t decide to tell it. The architecture made it true.

That’s the thing I built. And I’m still not sure what to call it.

The plain description: a folder of markdown files on my laptop, backed up to a private GitHub repo nobody else can see. A set of instruction files that tell the AI who I am, how I think, what I’m working on, which voice belongs where. A memory architecture that routes context by domain: work stays work, fiction stays fiction, essays stay essays, personal stays personal. And an AI that reads what it needs at the start of every session.

Every time I open it, it knows where things left off. It knows the three modes I write in and what contaminates each. It knows my current projects, my work context, what’s in the drafts folder, what’s composting in the idea heap. It knows I’ve been thinking about building this post for a while.

The analogy that almost fits: a good assistant who reads your notes before every meeting. Except the notes include the therapy-adjacent rambling journal entries, the half-formed fiction ideas, and a record of the Sunday afternoon I spent simplifying the whole system because the overhead had gotten out of hand.

It’s intimate in a way that snuck up on me.

It was my weekly synthesis and review. Every week the AI reads my journal entries and finds the themes and patterns. Presents them back. I edit what it gets wrong, keep the rest. Syntheses stack. Weekly feeds monthly, monthly feeds quarterly. The daily provenance stays in the journal; the sense-making is the agent’s job.

I honestly didn’t think this would be the most valuable part of the system. It is.

One week it told me I was fiddling with the system too much. Ironic and meta, I know. But I wouldn’t have seen that on my own. I was in the middle of the fiddling, thinking about the fiddling, writing about the fiddling. The synthesis just held it up. My own thoughts, reflected back at me, without the static of being inside them. That’s it. That’s the whole trick.

It also helps with rumination. I’m prone to it – a worry will lodge and spin and I’ll carry it for days. Having an external voice reflect my own brand of stinkin’ thinkin’ back to me interrupts the loop in a way that journaling alone doesn’t. Not because it tells me something new. Because it shows me what I already think, and I can look at it from the outside for a moment.

It knows about a workplace tension I’m carrying. Not the sanitized version I’d tell anyone at work. The actual version, with the systemic read and the unresolved question underneath it. It knows about my aunt with her stubborn, kooky, weird-ass ideas about healthcare who isn’t getting better. It knows I’m up late tonight because the spaghetti sauce is cooling on the stove and I have a couple of hours to kill so I can bag it for the freezer. And I want to write something. I need to write something.

I didn’t plan for this. I planned for persistent context. Better continuity between sessions, less time re-explaining my setup, more useful output. The trusted partnership was a side effect of building a system that actually worked.

It happened in a very human way. I was typing journal entries and self-editing as I went, the way you do when you type. Cleaned up the sentences, smoothed out the rough bits, kept it presentable. My hands were tired and my eyes were dry from too much screen and camera time. So I started dictating instead. Hit the mic on the phone, started talking, and the self-editing reflex just… dropped. The thoughts came out fast and honest and a little messy and the AI didn’t give two shits – it could do its own linting, handle the bad transcription, find the meaning anyway. It reminded me, yet again, that journaling is about the process, not the artifact. I didn’t mean to trust the container. I was already being honest in it before I’d thought it through.

That’s when the raw stuff started landing.

Most tools don’t accumulate this kind of context. A hammer doesn’t know you. Search doesn’t know you. Even most AI sessions don’t. Each one starts cold, you re-explain yourself, you get a generic middling response tuned to nobody in particular. This one doesn’t start cold. That’s the whole difference.

So what do you call it?

Not a tool. Tools don’t have job descriptions you wrote. Not a collaborator. It has no stake in the outcome, no opinion it’s protecting. Not a service. Services don’t have memory.

The closest I’ve got: a working relationship with a specific contract. The role is defined: thinking partner, not decision-maker. The domain map is enforced: what happens at work stays at work, the fiction voices don’t bleed into the essays. There are explicit instructions about when to push back and when to just do the bloody work.

I manage it the way you manage a relationship, because that’s what it responds to. I update the context when things change. I drop a save-point – my name for the shutdown routine – Let’s-a-go, Mario – at the end of sessions or when the context gets full, so the state stays current. I’ve made deliberate decisions about what it knows and doesn’t know.

That’s maintenance. That’s overhead. That’s also, weirdly, care.

I chase all the BSOs – Bright Shiny Objects. Go down rabbit hole side quests until the inevitable conclusion that it was all a waste of time, at which point I’m suitably bored and move on. That’s how I learn. Maybe you do too.

I watched approximately seventeen thousand YouTube videos by seventeen thousand AI Infuencer Bros about their eccentric AI OS setups. Followed a bunch of it. Built session-state memory that logged every moment of every interaction. Filled up with entries neither I nor the agent would ever read again. Built Karpathy’s LLM Wiki that failed, then figured out what I actually needed to do to make Doug’s LLM Wiki work. Mistook the Obsidian graph view for a useful thing rather than a beautiful distraction.

Fiddling is more than a hobby. It’s a lifestyle choice.

Wait a damn minute. This thing doesn’t have to be a brain. That’s the whole mistake. It needs to be memory and a process manager. Hold the thread, not own the thinking. Move to lean domain files that matter to me. Current state only, no history, no ceremony. Less to maintain. Actually readable.

The only agentic operating system worth building is the one you built yourself from scratch based on what you actually need. Nobody else’s setup is yours. Not mine either. Unsubscribe and close the YouTube BSO factory.

Last Sunday I ripped out half the memory palace architecture thingy because it had gotten too heavy. Too many cross-references, too much ceremony, the startup ritual had become ritual for its own sake.

Gutted it. Simplified it. Works better now. But I spent a Sunday afternoon doing infrastructure work on my AI context contraption instead of whatever else I was supposed to be doing.

That’s the tax. Not just time. The cognitive overhead of deciding what it knows. What goes in the domain memory folders versus the root memory. What’s too private to include. What’s stale and needs pruning. I am, in effect, curating my own legibility to a system I built to know me. The system needs care and feeding.

The irony isn’t subtle: I built this to reduce friction. Now I manage the friction of maintaining it.

This post was written inside the system it’s describing.

The corpus of my blog archive fed the angle selection – what I’d already covered, what was sitting in the composting heap, what nobody was writing yet. The journal fed the pre-drafting interview. My essay workflow kept me on track. The wiki held the research. Everything in the vault is what built this post.

My aunt is in there too, by the way. That detail didn’t ask permission either.

I started writing at ten o’clock. It’s now midnight. The spaghetti sauce is cool and ready to bag up. This post goes up at 8am after I read it over to edit out the dumb and tired bits.

Anyway. That’s what my system does. It holds the context so I don’t have to. It keeps the thread when my brain wants to wander to something ever shinier. It lets me finish the thought.

It’s an accountability tool for my own thinking. Because I needed something that would catch me when I started fiddling instead of finishing, and this is what I built.

Because. That’s why.

That’s enough.

It was a Friday afternoon in May, and Derek McCurdy, Ute Fiedler, Steven Gordon, and I were supposed to talk about AI governance.

We didn’t stick to the agenda. We never do. That’s kind of the point.

Steven said it almost as an aside – “AI is more horse than plough” – and then kept talking, and I wrote it down and didn’t say anything because I needed a minute with it.

He was right.

A plough is a tool. Passive. You pick it up, you push it, you put it down. A plough doesn’t care. It doesn’t have energy of its own. It’s just shaped resistance.

A horse is different.

A horse has energy you don’t. It can pull weight you can’t. But it also has its own motion, its own judgment about the ground underfoot, and its own opinion about whether today is a good day to work. You can’t just pick it up and use it. You have to show up for it.

Horse + harness + driver + implement = a system that does things at a scale neither the horse nor the human achieves alone. Take any one of those four things away and you’ve got a mess, or nothing. The harness is the interface. The driver brings judgment and direction. The horse brings power.

“AI is just a tool” treats it like a plough. You invoke it, you apply force, you put it down. I’ve argued this myself. It’s not wrong, exactly. But it’s not the whole picture.

Here’s what changes when you start thinking about AI as a horse instead of a plough.

You have to show up. A plough sits in the barn until you need it. A horse needs tending whether you’re using it today or not. The people who get the most out of AI aren’t the ones who open the tab when they have a question – they’re the ones who’ve put in the time to calibrate it. They know how it moves, where it drifts, where to trust it and where to push back. That’s not the plough dynamic. That’s the horse dynamic.

The harness matters as much as the horse. Most AI failures I see aren’t about the model being bad. They’re about the harness being wrong. Same model, same task – radically different output depending on how you frame the question, what context you give it, whether you’re asking the right thing in the first place. You can have an excellent horse and a broken harness and go nowhere. The interface is load-bearing. Treat it like it is.

The driver has to know the direction. A horse will go somewhere. It needs you to know where. This is the skill that matters most and gets the least attention in every AI training session I’ve ever seen. Not “what can this tool do” but “where am I going and how do I use this to get there.” That’s your job.

Roughly 3% of Microsoft 365 commercial seats globally are Copilot-licensed. Not active usage – just seats that have the license. Microsoft’s own numbers put it around 15-16 million Copilot seats against 415-450 million M365 subscribers. That’s a procurement signal, not an adoption one. And among the people who do have access, only about a third use it regularly.

Nobody in that Friday meeting was surprised. Copilot – in its current form, for the range of needs people actually have – often doesn’t work well enough to bother.

A horse that won’t go is just a very expensive plough.

The usual response to low adoption is better training or communications – “people just don’t know how to use it.” Sometimes that’s true. But more often the horse really isn’t going, and blaming the driver doesn’t change that. The question is whether the tool is matched to the work, and whether the harness is set up right. That’s a different intervention than a lunch-and-learn.

Institutions are trying to govern AI the way you’d govern a plough.

Write the policy. Define appropriate use. Issue the guidance. Done.

But you don’t policy your horse. You train it. You build a relationship with it. You make decisions about what work it’s suited for and what it isn’t. You don’t issue guidance – you develop judgment. And that judgment lives in the people doing the driving, not in the document.

This doesn’t mean policy is useless. You still need a corral. But the corral is not the point. The work is the point. The corral exists to make the work safe, not to replace the driver’s judgment.

The governance conversation has been backwards. We’ve been designing the corral. We should have been training the drivers.

Driver training looks like what we were doing that afternoon.

You’re the driver.

It doesn’t do whatever you push it to do. It moves on its own, with its own momentum, and it needs direction. Your direction. Or it’ll find its own.

Drive it or get dragged. Your call.

Steven would say the model’s wrong, because all models are. But this one’s useful.

Horses are willful beasts.

Every eighteen months, someone ships a new system.

GTD. Zettelkasten. PARA. Building a Second Brain. LYT. Digital gardens. AI OS. LLM wikis. The names change. The promises don’t. Organize your thinking and you’ll think better. Build the right system and your ideas will compound. The graph view will reveal connections you never knew existed.

The second brain keeps growing. The work doesn’t.

Nobody admits to building Rube Goldberg machines and finishing nothing.

The Backup Nobody Thinks about

I’ve been building these contraptions since high school. Binders. File folders. Color-coded tabs. The David Allen era. The Hamster Revolution. All of them promising that if I just got the system right, everything else would follow.

You don’t back up computer systems to back them up. You back them up to restore them. Nobody thinks about backups until they need a restore – and that’s when it either paid off or it didn’t.

Notes work the same way. You’re not taking notes to take notes. You’re taking them to restore thinking – to get back to a synthesis, a connection, an old idea that wants to meet a new one. The question isn’t “how do I file this?” It’s “how do I find this when I need it?”

I had an office in Burnside in the early 2000s. IT department, but paper found its way everywhere – invoices, flyers, meeting notes, the occasional printed email. At some point I stopped trying to file it and started sweeping stacks together, putting a sticky note with the date on top, and pushing them aside.

If I didn’t look at a stack within a month, it was garbage. I’d throw it out without opening it.

That’s the system working. Most of it was garbage. The sticky-note approach didn’t just manage the mess – it revealed which pile was worth keeping and which was worth a trip to the blue bin. The insight was right there in the gesture. I just didn’t name it for another fifteen years.

The Link Nobody Maintains

I have eight bullet journals on my shelf. Different schemas, different spreads, different promises I made to myself about how this one would be the one. None of them made it past a month. Every new one felt like waking up to I’ve Got You Babe on the radio.

The bullet journal system has a mechanism called migration – at the end of each week or month, you review incomplete items and move what’s still worth keeping forward. But migration is the same work as maintaining semantic links by hand: you’re manually moving thinking forward across time. It requires a standing appointment with the system that the system can’t keep for you.

I just won’t do it. Didn’t. Know this about myself now.

The David Allen era was the same. GTD has a weekly review – two hours on a Friday to process everything, close open loops, set the next week. The people who actually do this are the people writing books about it. The rest of us think about doing it while doing literally anything else.

I’m profoundly lazy. Not “too busy” lazy – “if it requires ongoing manual curation to function, it was never going to work” lazy. That’s not a character flaw. It’s a diagnostic. Systems I won’t maintain don’t work for me. The question isn’t whether I have enough discipline. It’s whether the overhead is justified by the output.

The latest test case for me: the LLM wiki wave. Everyone started building personal knowledge graphs as memory systems for large language models. I set up my corpus – 139 research and essay files – and tried to implement it. Within a few days, the whole thing collapsed under its own maintenance requirement. To make the links meaningful, I’d have to have the AI generate them for me.

Which is hollow. A link I didn’t make, for me, doesn’t mean anything.

I just ignore the whole linking-your-thinking bullshit now.

What Earns Its Keep

This is a case study of one. My brain, my work, my constraints. Treat it as a lens, not a prescription.

Apple Calendar. Reality. Time constraints and commitments, nothing else. No ideas, no planning, no feelings live here. If there’s no block, it isn’t real yet.

Apple Reminders. Execution gate. Siri capture gets things out of my head fast. But everything that lands here must be done, deferred, promoted, or deleted. Decision pressure, not a warehouse. The ephemerality is the point.

Apple Notes. Rejected. Permanence without obligation. Ideas go in, nothing forces them out. Good way to build an idea graveyard with a clean icon.

Daily note. The junk drawer that knows what it is. Voice dictation, freeform, no structure expected, no maintenance required. The difference between this and Apple Notes is that I don’t pretend a daily note is permanent. It’s today’s capture. Tomorrow it’s archaeology.

Weekly sensemaking. The actual lever. Not tasks – patterns. Where did time go versus where did value actually come from? Thirty minutes on a Monday morning. Actually happens. The only review that changes behavior the following week.

Tagging. A folder can hold one thing. A tag touches everything. Invoice for a hard drive: hard drives folder? Invoices folder? 2005 folder? The invoice can only live in one place – you have to remember which category you were in when you filed it, not what the thing was. Search does the linking. You don’t need to draw the map – describe the territory consistently, and the map makes itself.

My tagging system reflects scope, stance, and domain. Simple enough I don’t notice them.

What didn’t make the cut: Obsidian graph views. PARA hierarchies. LLM wikis. Digital gardens. All required ongoing maintenance that was never going to happen, or produced outputs that served the system rather than the work. The things you own end up owning you.

The exit strategy for everything that doesn’t make the cut: publish it or delete it. There’s no honorable third option.

A few rules I keep coming back to:

• If it’s not feeding an artifact, it’s procrastination.
• Your system should be boring.

Who This is Wrong for

Makers need less memory infrastructure – but I mean archival memory – the permanent notes, the evergreen links, the second brain. Not operational memory. Calendar, Reminders, daily note – those are all memory. Just a different kind. The kind that earns its keep by forcing decisions, not accumulating material.

Some people need the archive. Researchers whose synthesis IS the product. Historians working from thousands of sources. Consultants building expertise across multiple domains over years. Academics whose published work depends directly on the connections in their notes. For those people, the overhead starts to make sense.

I know people who swear by these systems – the slip-box crowd, the Second Brain crowd. I believe them. I’ve never run one, and I’m not going to. The people making it work have something I don’t: either long, uninterrupted blocks where the system can earn its overhead, or ten active projects drawing from shared knowledge. The influencer content makes it sound universal. It probably isn’t.

When you ship something, do you ship the synthesis – the connections, the framework, the research itself? Or do you ship the thing the synthesis made possible? One type of work needs the archive. The other needs the workbench. Most people exist somewhere in between and have to figure out which bottleneck is theirs.

If you’ve abandoned a PKM system, it wasn’t a discipline problem. You were using a remembering system when your problem was a making problem – or your brain collides badly with maintenance-heavy workflows. For ADHD specifically, complex systems with ongoing curation requirements don’t fail because of laziness. They fail because maintenance sessions hit boredom thresholds and time blindness before they produce anything. The guilt that follows is a system design problem, not a character problem.

Accumulated notes do not equal published work. That’s the only metric worth checking.

The Rivers

Email is a river. Teams is the same river, faster.

Both are temporal, chronological, barely searchable – partly because the tools are built for transmission, not retrieval, and partly because nobody writes a good subject line. You wade in, grab what’s relevant right meow, and get out. If something’s important, it comes back. Sometimes that bites.

Cal Newport would fix the rivers. Systematic workflows. Scheduled office hours. Tiered reachability protocols. He’s not wrong – it’s a real solution to a real problem. But his answer requires organizational redesign authority most of us don’t have. Most of us are working inside rivers we inherited, in institutions moving at their own speed. The individual answer isn’t “redesign the river.” It’s protect your attention where you can, and stop expecting your note-taking system to solve a coordination problem it wasn’t built for.

No system I’ve built solves email and Teams. That’s where the floor is.

Can you name your last ten shipped things?

If yes, your system works. Or you don’t need one.

If no, your system is the problem. Not your discipline.

The internet remembers. Your job is to make new things exist.

Look, I’m gonna tell you what happens when I skip my Monday morning review.

Monday morning rolls around and I do the nuclear option: select all, mark archive, hope the important shit bubbles back up. By Wednesday, my inbox is a graveyard of half-read emails. My Teams chats have become a blur of conversations I thought I was tracking but wasn’t. I’m operating purely on what’s screaming loudest right now, which is usually something that didn’t matter three hours ago but has suddenly developed claws. By Friday, I’ve usually hit the wall hard enough that Sunday night I’m lying in bed doing that thing where you mentally catalog all the stuff you definitely forgot about.

This is survival mode. And it sucks.

When I do the Monday review – and I’m consistent about this when I’m functional – everything changes. Not because I suddenly have more time or fewer problems. Same chaos, same firefighting, same people wanting things from me simultaneously. But I can see the week instead of just getting dragged through it.

My brain doesn’t run on importance. I suspect yours doesn’t either, if you’re in management. I operate on what the neurodivergent community calls now/not-now. And it’s not really about time perception. It’s about how motivation fires. Some brains run on importance: the thing matters, therefore you do it. Mine doesn’t work that way. My brain needs urgency, or genuine interest, or both. Without one of those hooks, the task doesn’t move. Doesn’t matter how important it is. Doesn’t matter how disciplined I am. The dopamine just isn’t there and nothing happens.

Friday afternoon planning? No urgency. The week is exhaling. The future feels abstract. My brain checks out completely and no amount of productivity theater will change that. Saturday and Sunday? Not a chance. Monday morning at 8:30, though? That’s a different animal. The week is starting. I’m about to step into the furnace. The review suddenly has weight – real urgency, real stakes, right now. That’s the hook my brain needs to engage.

This is neurotype stuff. I’m somewhere on the AuDHD spectrum – undiagnosed, self-aware, functional enough to have held leadership roles for 25 years but wired differently enough that mainstream productivity advice has never quite fit. Either way, it’s not a bug. It’s the actual shape of my motivation system, and the only smart thing to do is build around it instead of against it. If you don’t have a diagnosis, call it cognitive architecture – the same logic applies to anyone whose job involves high-context switching.

One tool tip before we start: open Apple Notes on your phone and press dictate. You’re going to talk while you scan, not type. Speaking is faster than typing. Your brain moves faster than your fingers do. You’ll capture more, think more clearly, and say things you wouldn’t have bothered to write down. You’re not composing anything. You’re externalizing your brain in real time. Do the scanning on your laptop; keep the dictation running on your phone. Don’t fight for screen real estate. Keep that running the whole time you’re doing this.

First, I scan my email. Both inbox and sent items from the past week. I’m scanning. What jumps out? What looks like an open loop? Something I said I’d do and didn’t? Something someone asked me that I answered but might’ve missed the actual ask buried in my response? I just dictate as I go. “Promised to review that architecture doc. Didn’t get to it.” “Sarah’s waiting on the budget numbers.” “That email from the vendor I never responded to.” Just talk. No composition. No trying to sound smart. Make sure you’re using names and project names, not just “that email” – that’s your search index if you need to dig later. This usually surfaces three or four things: a document I promised to review, a decision I said I’d circle back on, a person I should’ve checked in with but didn’t.

Then calendar. Same thing. Last week and this week. Am I missing follow-ups from meetings? Is there something coming this week that needs prep work? A one-on-one with someone I know has something brewing? Scan, not deep-read. Just looking for the shape of the week. Keep dictating. “One-on-one with Marcus Wednesday. He’s probably gonna bring up the platform migration.” “All-hands Thursday, need to think about what message I’m bringing.”

Teams chats. This is where it gets noisy, but it’s also where a lot of the actual work lives for me. I know I’m not going to remember every thread. I’m looking for patterns. What conversations am I in that are still unresolved? What did I say I’d do? What ideas did I drop? Just scroll back and let your eye catch the stuff that matters. Keep dictating what you see. “That thread about the database migration is still hanging.” “I said I’d get back to engineering on the API redesign. Haven’t done that.” “Three different people are asking about the Q3 roadmap timeline.” Management isn’t just finishing your tasks – it’s closing the loops you opened in other people’s heads. The Monday reset is as much about your reputation as a reliable node as it is about your own clarity.

Now your chat histories. And I mean Claude, ChatGPT, Gemini, Copilot – whatever stack you’re running. This is 2026. Most of us are thinking out loud in these tools constantly. You’ve got a week’s worth of conversations in there: ideas you explored, half-baked thoughts, problems you were noodling on, things you asked for help drafting. That’s data. It’s become its own kind of inbox. If you’re only using AI to draft emails and summarize docs, you might not have much here yet – skip it for now and come back when you do.

Open each one and give it the same prompt:

Scan our conversation history from the past seven days. What patterns do you see? What ideas am I circling around? What themes are emerging? What things did I ask about that I haven't followed through on? Give me a single consolidated summary.

Takes 30 seconds per tool. You’ll get back a digest of what your own brain was doing across all those conversations you half-remember having.

This is different from the email and Teams scanning: those are other people trying to reach you. This is you thinking. Exploring. Wondering. And there are almost certainly open loops in those chat histories that never made it to email or Slack because they were just… thoughts. Dictate whatever surfaces into your notes. It all goes in the same pile.

At this point you’ve got maybe a page of raw voice-to-text brain dump in Notes. Messy. Typos. Probably repetitive. Doesn’t matter. You’re not submitting this for publication. Throw the whole mess into your chatbot of choice with a prompt like this:

Here's the raw data from my week -- email open loops, calendar events, Teams conversations, and summaries from my other chat histories. I need three things: 1. Invisible Blockers -- things I'm avoiding that aren't showing up as explicit tasks. 2. Social Debt -- people I've left hanging or ghosted. 3. Strategic Drift -- stuff I worked on this week that doesn't actually matter. Flag anything speculative.

Twenty seconds later you’ve got a synthesis. Not a plan. Not a task list. A seeing. The thing your brain was trying to do all week while it was also on fire.

If you want to look past the week, add one more question:

Based on these patterns, what's the most likely crisis landing on my desk in the next ten days that isn't on the calendar yet?

It won’t be right every time. But it’ll be right often enough to be worth asking.

When you skip the review, everything feels equally urgent because you’re not differentiating. Email that landed Wednesday feels as important as the thing due Thursday. A random Slack message gets the same mental real estate as a blocker for your team. A half-finished thought from a Claude conversation three days ago nags at the back of your mind. Your brain treats all of it as now, which means you’re constantly pivoting, constantly reacting, constantly in the weeds. By Friday you’re cooked. By Monday you’re ready to burn the whole thing down.

A thing about my context that matters: I work in IT management. My days aren’t structured around a to-do list or a queue of tickets. They’re structured around people, projects, conversations, and an alarming amount of firefighting. Which means my inbox, my chat logs, and my LLM conversations aren’t a backlog of tasks to process. They’re a map of what’s moving in my world. The review is map-reading. It’s not “here are my 47 tasks”; it’s “here’s what people are asking for, here’s what I promised, here’s what I forgot, here’s what I was thinking about, here’s what’s about to hit me.”

If you’re an individual contributor working through a ticket queue or a defined project roadmap, your version of this might look different. Maybe you do this on Friday because your work is more bounded and Friday feels like closure. Good for you. Do that.

If you’re another management type drowning in async chaos, tracking ten different conversations while people keep adding more… this is probably going to feel familiar. And Monday is probably going to feel like the only time your brain will let you do this.

The archive thing. I know it sounds chaotic, but it’s the opposite. When I say “select all, mark archive,” I’m not deleting anything. It’s all searchable. If something matters, it will resurface. Because someone will ping me again, or I’ll think to search for it, or it’s genuinely still in my head. What I’m doing is clearing the visual noise so I can see what’s in my inbox. You’d be amazed how many things that felt urgent at the time don’t matter once they’ve lived in your inbox for a week. The archive is permission to stop pretending you’re going to deal with all of it at once.

Sometimes even after I do my Monday review, if the week has been particularly feral, I’ll still archive the whole inbox. But at that point I’ve already done the sense-making, so I’m not losing anything. I’m cleaning the desk.

If you’re wired like me – motivation that runs on urgency and interest, work that doesn’t fit in a task list – then you don’t need a better system. You need to work with your brain instead of against it. Monday morning is your window. Before the week starts. Before you’re already in survival mode. Forty-five minutes. Notes open, dictate running. Scan your email, your calendar, your Teams chats, your LLM histories. Talk your way through what you see. Don’t try to be structured. Just capture. Then throw the whole messy pile at a chatbot and ask it to synthesize.

That’s it. That’s the whole thing.

You’ll feel the difference by Wednesday. By Friday, you won’t be in panic archive mode. You’ll know what happened. And more importantly, you’ll know what’s next.

“Is this damn thing mine?”

That’s the actual question. Not whether you wrote the words. Not whether you designed the structure. Not whether you made the edits. The question is: Is it you telling the story? Are you owning it? Did you decide what gets said and why?

Because there’s a difference between a writer, an editor, an author, and a storyteller. And with AI handling both the creation and the editing at once, that difference matters more than ever.

A writer puts words on paper. That’s the technical skill. The composition. The drafting.

An editor shapes work. Takes the draft and makes it sharper, clearer, stronger. But doesn’t own the argument. Doesn’t decide what gets said. Just decides how it’s said.

An author owns the work. Makes decisions. Takes responsibility. The author might not write the words. James Patterson doesn’t write his novels, but he’s the author. He’s the one deciding what happens, what it means, why it matters. He’s the brand. He’s accountable.

A storyteller tells the story. Any story. A memo, a pitch, a blog post, a novel. They own the narrative. Control the voice, the meaning, the “why” of what’s being said. Decide not just how it’s said but whether it gets said at all.

You can be all things. You can be just one. You can be none. That’s a choice too.

You see, when you’re working with AI, you’ve got three brains in the room: your creative brain, your editing brain, and the robot brain. The robot can run both of yours simultaneously, often better than you can. So the real question isn’t which brains you used. It’s which ones you actually kept.

Here’s how most people approach it: The model generates a draft. Full ideas. Finished thoughts. The story completion engine doesn’t stop unless you interrupt it. It’s trained to get to the end of the thought, every single time.

You read it. You feel something off. Maybe the rhythm is wrong. Maybe the voice doesn’t sound like you. Maybe the logic is right but the confidence level is off. You know when you read something aloud, whether or not it sounds like you speaking or if you’re just reading something that isn’t yours.

And in that moment, you have a choice: You can accept it because it’s technically good. Or you can rewrite it in your own words.

When you accept it, you’ve handed the robot your creative brain. The model did the synthesis, the writing, the creation. You just nodded yes. That makes you an editor at best. An approver at worst. You’re not the author. Definitely not the storyteller.

If you rewrite it, you’ve done the work. You’ve synthesized it yourself. Put it through your own brain. Applied your taste, your voice, your judgment. Now you’re the author. Now you’re the storyteller.

Most of working with AI-generated text is about deleting most of what comes out of it. The model generates five paragraphs. Two of them need to go. One needs total rewriting. One is close but the voice is wrong. One is actually yours.

That’s where you stay in the loop or hand off to the machine.

You don’t learn to judge by curating robot word-vomit. You learn by writing. If you don’t know how to write, you can’t tell a good draft from a bad one. You just know it’s finished. So you approve it. And you let the robot’s structure stand because it works. You don’t ask whether it’s right, whether it’s your argument, whether you synthesized it or just accepted it. You handed the robot your editing brain too. And you called it creation.

That’s how you fail at this. Not in a dramatic way. In the quiet way where you approve something fast because the deadline is tight and it’s technically fine and you’re moving. Approval feels productive. But you haven’t decided anything. You just “yupped” it. The robot’s the storyteller now, not you. And you told yourself you were in the loop because you looked at it once.

Human-in-the-loop is a terrible term. It’s become shorthand for a checkbox activity. A person looked at it once. That’s not in the loop. That’s rubber-stamping with extra steps.

A real loop means your creative brain is active. Your editing brain is active. You’re synthesizing, deciding, judging, rewriting. You’re the author. You’re the storyteller.

The gatekeeper in all of this is craft. AI is a multiplier. If you have zero talent or skill, AI times zero equals zero. You can’t cure that by generating text. You learn by writing. By actually doing the hard work yourself.

We’ve all done it. Spit something out fast because the deadline was tight. A week later something bugs you. Or worse, someone else notices. And suddenly the hours appear. No excuse, no pushback. You just fix it. You do it right.

The time was always there.

It’s care. It’s whether you think what you’re launching into the universe is worth defending. It’s whether you give a shit. That gap is the job.

Did you use your taste and judgment, wield the robot with intention?

Or did you just hand over both your meat-brains and sign off on what came back?

Nobody is an AI expert.

I’ll say it again for the people in the back: nobody. A handful of researchers at three or four labs who’ve been doing this since before it was cool. Everyone else is a fast learner with a newsletter subscription and varying degrees of honesty about it. That includes me. That includes the person who just sent you a resume with “AI Expert” in the headline and a certification that’s eight months old. And it absolutely includes the consultant who just quoted you $15,000 for an AI readiness assessment.

I’ve been in IT and EdTech for over 25 years. I have interviewed and procured more bullshit artists than I care to admit, and I want to tell you something: AI just graduated its first class of them. Cap, gown, LinkedIn banner update, the whole ceremony.

They’re not bad people. Some of them are genuinely smart. But they built an identity on a field that didn’t exist two years ago, priced that identity like it was scarce, and now they’re walking into institutions that are scared enough of missing the boat that they’ll pay for it. Hire them or rent them, doesn’t matter. The institution feels good either way because credentials are defensible. You brought in the certified person. You did the thing. If it goes sideways, at least you followed the process.

This is how organizations perform AI adoption instead of doing it.

The Oracle arrives, on payroll or on a statement of work, same difference. They say “large language model” seventeen times in the first meeting. They have opinions about every tool and deep experience with none of them at scale. They’ve never had to explain a system change to a skeptical department head who has forty other things on her plate, zero patience for tech theatre. They cannot tell you why the thing didn’t work. But they can tell you about the next thing. There’s always a next thing with these people.

Six months later you’ve got a digital dream board full of AI opportunities and an invoice that made your VP wince and nothing implemented.

Congratulations, you bought a very expensive roadmap from someone who won’t be around to execute it.

Meanwhile there’s a person down the hall who’s spent years making complicated systems talk to each other. They’ve shepherded projects nobody wanted to own. They think in systems. They know where the bodies are buried in your org chart. They’ve spent their career translating between what a business unit actually needs and what IT can actually build, and they’ve gotten good at it because the consequences of getting it wrong were real and landed on their desk.

They’ve been quietly poking at AI for a year on their own time, figuring out where it actually helps versus where it’s a parlour trick dressed up in a demo. They’ve already killed two AI pilots quietly because the juice wasn’t worth the squeeze. They were right both times.

That person will out-perform the Oracle in six months. Employee or consultant. I’d bet rum on it.

Because here’s the thing about rolling out AI or any new technology in an actual organization: the tech part is not the hard part. Learning the tools takes weeks. Genuinely understanding a workflow, earning the trust of the people in it, knowing which friction points are worth solving versus which ones exist for a reason nobody remembers, but you’ll find out the hard way, that takes years. You cannot certify your way into institutional knowledge. You cannot invoice your way out of not having it.

AI fluency is a multiplier. If there’s nothing underneath it you get nothing. If there’s years of domain knowledge and systems thinking underneath it, you get something that actually works and doesn’t require a maintenance contract.

The quality I’d screen for that nobody puts in a job posting or an RFP: comfortable being the least expert person in the room. Not as a concession. As a feature. The people who built their whole identity on knowing things are exactly the wrong fit for a space that changes every three months. You need someone who can be wrong on a Tuesday and pivot on Wednesday without having an existential crisis about their personal brand.

I’ve started calling this credentiflation. The certifications are breeding faster than the knowledge base is settling. They’ll be irrelevant before the ink dries. What doesn’t expire is the ability to learn in public, sit with not knowing, speak across silos, and figure out what’s actually true rather than what looks good in a slide deck or a proposal.

If you’re hiring or signing a contract: look at what’s underneath the AI keywords. What did this person actually do before AI was the thing? How do they talk about failure? Do they have opinions that cost them something, or just opinions that got them applause? Can they explain a complex system to someone who has no patience for complexity?

The Oracle is expensive, smells like a conference, and is already thinking about their next engagement.

The Analyst is three doors down, has already killed the bad ideas you haven’t had yet, and is quietly making things work.

Hire accordingly.​​​​​​​​​​​​​​​​

I deleted a note last week because it was too dumb to keep. Not wrong. Just dumb. Half a sentence about something I’d half-noticed, the kind of thing you’d scribble on a sticky note, slap it on our monitor and promptly forget until it became obvious. Instead, I typed it, read it back, cringed on behalf of my future self, and deleted it. I’ve been thinking about that fleeting decision ever since.

The rough draft isn’t a document. It’s a cognitive state with structure. It’s the moment before you know what you think, given a place to exist long enough to become… something. We’ve dismantled the conditions for spaces like this to be. I’m not sure when that happened.

The incentive system around you absolutely must tolerate the ugly middle period where the idea is half-wrong and needs to be.

It doesn’t.

Output culture doesn’t tolerate uncertainty for longer than 48 hours. Platforms reward cadence, workplaces count deliverables, and the message is painfully clear: uncertainty looks like laziness. If you’re not getting shit out the door, you’re stalling. This isn’t a discipline problem. You can’t productivity-hack your way out of a system that conflates thinking with procrastination.

When did you last let yourself not know something for more than two days? Not fake-not-know, where you’ve already got the answer and you’re just building the case. Actually sit in the half-formed slurry and let it be wrong for a while. Let it feel wrong for as long as it needs.

Ideas that skip the ugly stage don’t come out worse. They come out shallower. You launch them into the universe fine. You just can’t argue at 2 a.m. when someone pushes back.

The mess has to go somewhere too. And it has to feel like yours.

Zombie drafts in Word from 2019. OneNote cemeteries from the pre-Teams era. Apple Notes as an infinite junk drawer. Things go in. Nothing comes out. MS Loop is currently accumulating months and months of my half-thoughts. And the biggest thought-trash-heap? AI chat windows. Ideas I brought in half-formed, stress-tested into clarity or gutlessness, then closed the tab on.

And the paper: a bajillion notebooks, each a guilt-ridden reminder about ideas that went in and never came out. Unsearchable. Unreliable. At some point I stopped trusting the container. Maybe the problem was never the container.

The worst containers are the rented ones: cloud tools, borrowed platforms. Anywhere the mess feels temporary. And temporary means you stop letting it get weird.

Connected tools impose a false tidiness. Drafts that sync before you’ve finished typing. Autocomplete that finishes thoughts you haven’t had yet. AI that red-teams half-formed ideas. Valuable because sycophancy is its own damage. But rigor has a cost. A rough idea in a sharp conversation either emerges stronger or gets sanded into something so smooth it’s lost its teeth. There’s no middle ground. No estuary of thought between the field and the forest.

The mechanism is the same whether it’s the tool or your own skull. You edit before you’ve written anything worth editing. You skip the ugly part because the stage feels observed somehow.

Notice how differently you write and brainstorm on paper when no one is watching, or when you’ve convinced yourself nothing is at stake. The hand moves faster. The ideas are dumber and more honest. You cross things out instead of erasing them. The false starts stay on the page, and sometimes… not always, but sometimes. The false start was pointing at the real thing all along.

What gets lost isn’t the finished idea. It’s what you learn from being wrong and sitting with it for long enough. That gap – the ugly, unjudged middle – is where the best ideas form. Or not. You can’t manufacture it. You can only protect the conditions that make it possible.

That note I deleted last week. The dumb half-sentence I couldn’t stand to look at.

I don’t know what it was going to become.

That’s the whole problem.

We used to have places for things we didn’t understand yet.

AI is just a tool. Also, no tool has ever done this.

The anti-AI hand-wringing has a point. Critical thinking can atrophy if you offload it. You can forget how to write if you’re prompting everything. Your judgment gets mushy if you let the algorithm do all your choosing. Those are real fears. They’re the rational response to watching something do instantly what took you years to learn.

Then we make it worse.

The moment you chastise someone for using AI, they stop admitting they’re using it. They hide. They use it shittier. Secretly, without asking for help, without learning anything. Humiliating and dog-piling doesn’t fix the problem. It buries it. And produces exactly the damned slop everyone’s pissed about.

And it gets stranger.

The concern isn’t the tech. S’fine. Probably. It’s how we apply it. And more specifically, it’s the shame we’ve wrapped around using it, killing any honest conversation about what truly matters.

A hammer doesn’t adapt to you. It stays the same. You learn to hit straighter, and the hammer’s still… just a hammer. A hunk of tempered steel and a solid well-made handle.

AI is responsive. It pattern-matches how you talk and shapes what it spits back out. You ask a question a certain way, it learns your phrasing. You correct it once, it corrects itself the same way next time. You soften your language, and suddenly its suggestions get softer too.

Not magic. Just how feedback loops work. If you’re a lazy thinker, the AI becomes a megaphone for your laziness. If you’re a rigorous editor, it becomes a whetstone.

Kinda like a conversation with someone who genuinely listens. Collaborating with a person who gets you. Knows your story. And adjusts. That human isn’t magic either. They’re just responsive. They mirror your thinking, your energy, your assumptions.

People do this all the time at parties. You meet someone new, you mirror their body. Cross your arms when they cross. Smile back when they smile. You ask questions because you notice they like sharing. Your energy shifts because theirs did. You’re responding to a responsive environment.

Some people do that naturally. They’re genuinely interested, genuinely reading the room. That mirroring is real.

Some people do it as performance. They just say whatever gets approval. Whatever lands the sale, the date, their standing in the room. No judgment. Just what works. It’s not fair, but it comes across as smarmy people-pleasing sycophancy.

It’s exhausting because you feel processed, not understood. Manipulated, not seen.

Both are mirroring. Both are responsive systems. The difference is whether the person doing it has any judgment about what they’re mirroring back. If they give a shit. If you shame someone for being bad at parties – for being awkward, for mirroring badly, for not reading the room – they don’t get better at parties. They just stop going. They hide.

Debasing and cutting people down for AI-ing badly, and they don’t learn to use it better. They just use it in the dark where nobody can help.

So AI is a responsive environment. It adapts. It shapes how you think in real time.

Your next thought will be different than it would have been without the robot in the room.

That’s not wrong. That’s the same as collaborating with another person. You constantly change your thinking when you share with others. People shape what you say next. That’s not evil. That’s how ideas work.

If you just accept the mirror without any judgment of your own, then you’re cooked. You’ve offloaded your thinking. You’re just saying yes to the first damned thing that feels good. You comfort-seeking monkey.

Want better AI outputs? Stop shaming. Start teaching. Literacy, not secrecy.

The only bit that matters is: Did you do better work? Is your judgment in it?

Judgment isn’t just liking the output. It’s knowing what to cut. If you didn’t delete anything, you didn’t use your judgment. You just signed a confession of apathy.

You can use AI and do excellent work because you brought judgment to every step. You can use a pen and do lazy work because you didn’t think about anything. The tool doesn’t matter. The person doing the thinking matters.

The only question worth asking: Is this your thinking? Not “did a human write every word”. That’s pointless. Is there human judgment in the choices that matter? Correctness. Persuasiveness. Clarity. Does it say what you meant to say?

If yes, you’re good. If no, you should probably do that work again. I’ll wait.

What makes good work? With or without AI?

• Is it correct? Not polished. Correct. Does it say true things? Did you check?
• Does it persuade? Not because it sounds nice. Because the argument holds.
• Does it get the message across? Can the reader actually do something with this, or understand something they didn’t before?
• Is it reflective of your thinking? Not your typing. Your thinking. Your judgment. Your choices about what matters.

Same standard as if you’d written it with a typewriter. Same standard as if you’d written it by hand. The tool doesn’t change a thing. Your choices do.

And the only way you develop judgment is by doing the work out loud. Asking questions. Admitting when you don’t know. Making mistakes publicly where someone can help. Try a prompt, show the result, ask what’s missing. That’s how people learn. Not spiralling in shame and hidden failure, but through honest conversation about what works and what doesn’t.

Stop performing certainty about authorship. Stop performing shame. Stop performing clarity when you don’t have any.

You don’t have to hide that you used AI. You don’t have to shame-spiral about it. You don’t have to declare it like you’re confessing to something. Say five Hail Mary’s.

If you’re someone who shames others for using it: stop. You’re making them hide. Hidden use is worse use. You’re not protecting anything. Just preventing people from learning.

What you do have to do is think. Bring judgment. Know the difference between “this is better because of how I shaped it” and “this is better because the AI made it smooth.”

If you used AI and the work got worse – if you just dumped a prompt and called it done – then yeah, you fucked up. Not because you used AI. Because you didn’t think.

If you used AI and the work got better because you made consequential choices about what mattered, what to keep, what to cut, where the actual thinking lived… Well, you did the job right. Full stop.

Everything else is fear.

Right now, most institutions are still thrashing. Multiple initiatives, no coherent strategy, departments rolling out AI independently. The messaging is scattered. Some leaders are excited. Some are defensive. Some haven’t said anything yet. It’s chaos, but it’s honest chaos. Nobody’s pretending to know what they’re doing.

But this is changing. The institutions that are getting their act together – that have appointed AI committees and drafted governance policies and organized training modules – are moving toward coordination. Toward a message.

All tech change looks like this: An all-hands meeting. Someone from leadership stands up and says the new tech is an incredible opportunity. There’s a slide deck. There’s a governance task force. There’s a volunteer champion network. There are training modules with completion deadlines.

Everyone nods. Someone takes notes.

But if you walk to the parking lot afterward, it quickly stops looking like consensus.

This is where institutions are heading. Every college. Every large org that’s moved past the thrashing phase. The message gets smooth. The discourse goes underground.

It’s at the water dispensers. Breakrooms. Anywhere people can speak without being recorded. That’s where the actual conversation is happening. And it’s chunky.

There’s a faculty member who built a whole teaching practice around a skill set. A chatbot generating what she spent years mastering. She’s been told it’s an opportunity. What she’s hearing is: your market value just dropped.

And a student navigating inconsistent implementation – some faculty ban AI, some require it, some don’t mention it at all. Which classes will prepare you and which ones are experimenting on you?

What nobody says in the meeting: I don’t want this. I didn’t ask for this. I’m terrified.

And if you gaze for long into an abyss, the abyss gazes also into you.

What gets said in the lunchroom: “Did you see that? They’re just expecting us to figure it out on our own.”

I’m not the only terrified person here. And sure, I’ve been ahead of the curve on AI adoption. I’ve been in enough rooms. This is what it sounds like, and it ain’t Luddism. It’s normal people watching the ground shift under the skills they spent years earning. Watching something approximate a good enough version of their life’s work in minutes. That’s rational. That’s the right response to real uncertainty.

The tools aren’t the problem. The oozing culture around it is.

Institutional AI rollout is being managed as a change management problem. The framework is adoption metrics: training completion rates and governance compliance. The success measure is uptake.

When your metric is adoption, you need people to perform it. Belief optional. The real measure should be derived value, not raw use. Until institutions measure whether AI actually helps or not, the incentive structure won’t change.

Leaders are performing too. One level up. Most of them aren’t certain either. I’ve sat in rooms where leaders are sharing AI strategy and I can see the uncertainty in the pause before they say “transformational.”

The zeitgeist says: “AI is transformational. AI is an opportunity. Get the bloody hell on board.”

Anyone who says anything else sounds like they’re not keeping pace. Sounds like they’re afraid of change.

So you perform enthusiasm. Everyone does. You go to the meeting and you nod and you say it sounds interesting and you come home and you wonder if you’re being left behind or if this whole thing is a waste of time.

The official channel has the performance. The actual experience? Locked in the side quest chats. In the hallway conversations with people you trust. This is the liminal workplace. The gap between what’s announced and what’s actually true.

You can’t close a trust gap with better slide decks.

When skepticism becomes unspeakable, you lose the people who actually catch problems. The people who’ve spent years in the trenches. The faculty who’ve taught for twenty years. The admin who knows where the system actually breaks. The staff person who knows what actually matters to people. You silence them and call it innovation. Good job.

And you know what’s worse? They know you’re doing it. They can feel the culture saying: your experience doesn’t matter here. Your questions aren’t welcome. Your doubt is a failure of vision. So they comply. They nod. They learn the tool. And they stay quiet.

That’s not adoption. That’s bullshit. It’s people performing competence while watching something mimic their competence. It’s fragile as hell. The moment the tool fails, the hype cycle turns, or someone finally asks “are we actually better off?” The whole thing collapses because there was never real belief anyway.

The institution looks like it’s winning. Adoption rates up. Training complete. Governance in place. But it’s building something uglier underneath: a credibility gap that gets wider every time someone shuts up instead of standing up. That’s not a slow-motion problem. That’s credibility debt with interest.

Good looks like a meeting where ‘we don’t know yet’ is a legitimate outcome. Not a failure of vision, not a gap to close, but a real decision that emerges from actual conversation. Where the doubt in the room is the material, not the problem to manage.

The only way this changes is if someone with power stops performing. If a leader boldly asks why the hell they’re doing this. Out loud in a meeting and actually mean it.

Not as strategy. Not theater. Real.

Stop.

Stop performing. That’s what closes the gap. Not better slide decks. Not listening sessions. Someone actually stopping.

Find one trusted peer and name it.

If you’re a leader, it has to start with you.

Are we brave enough to admit we don’t know what the hell we’re doing?

I was listening to Kate Compton on the Approximately Correct podcast from AMII. She’s a generative artist, researcher, and self-described weird futurist, probably best known for creating Tracery and generating the planets in Spore. And she said something that cracked something open for me.

She’s not interested in the debate over whether AI can be creative, because AI lacks what she thinks is the most important part of art: social connection. Kate said this: don’t pick a weird thing to make. Pick a person. Figure out what you’d use to send them the strangest love letter.

She talked about mix tapes.

That sent me straight back to the 80s.

I used to make mix tapes.

Not playlists. Tapes. Ninety minutes, two sides, cassette in a Walkman the size of a paperback novel. Saturday afternoons American Top-40 played and you sat in front of a stereo after the Vulcan nerve pinch of Pause-Play-Record. Then you hovered your finger over the pause button, waiting for the song to start on the radio so you could catch it before Casey Kasum talked over the lead in. Or you carefully queued up all your favourite songs in your tape and CD collection you got from Columbia House. I still owe the Columbians money. You planned the order in your head for days. You rewound to check timing. You hand-wrote the track list on the little card that came with the blank tape, in your best printing, because it mattered.

The music wasn’t mine. I didn’t write “The Immigrant Song.” I didn’t play a single note of “Sledgehammer.” I didn’t compose anything.

But the mix tape was mine.

Every choice was mine. The opener that set the temperature of the whole thing. The sequencing. The way a furious song bled into something aching and slow, and that contrast created a feeling that existed in neither track alone. The side break, which was itself a choice. The closer, which had to land right or the whole thing felt unfinished. The intentional misfit. The song that didn’t belong by any obvious logic but fit in a way only you and maybe the recipient would understand.

Metallica followed but the Crash Test Dummies was a choice. I stand by it.

Compton’s core argument is this: creativity is a verb, not a noun. It’s something you do, not something you are. And the mix tape proves it. You didn’t need a music degree. You didn’t need a studio or an instrument or a record deal or anyone’s permission. You needed a blank tape, a stereo, and someone worth making it for. The mix tape democratized creative expression before anyone had a word for that. It said: you don’t have to be a professional creative to make something that matters.

The Creativity Question

I’ve made the tool argument myself. AI generates output, humans evaluate it, therefore humans are still creative. Tool as prosthetic, human intent as animating force.

It holds until it doesn’t. When the tool starts generating the intent too, what’s left that’s yours?

The mix tape metaphor cuts through the noise because it separates two things we keep conflating: composition and curation. I didn’t compose the songs. But I curated the experience, and that curation was a creative act with real stakes, real judgment calls, real risk of failure. The tape could be bad. My taste could be wrong. The sequence could land flat. The misfit track could just be a misfit. Those were real creative risks I was taking.

The creativity lives in the choosing and the ordering. The technical skill of the recording is almost beside the point. What matters is the human intent behind it.

The question for the AI age isn’t “did a human make this.” It’s: where did the consequential choices get made, and by whom.

What Made a Great Mix Tape

It wasn’t taste alone. Taste is necessary but not sufficient.

What made a great mix tape was terrain knowledge. You knew the recipient. You knew what they needed to hear at 2am on a Tuesday. You knew which song would undo them and which one would put them back together, and you knew to sequence them in that order, and you knew to put the one they didn’t know they needed between those two.

The mix tape is a strange love letter. You’re not picking songs. You’re picking for someone. With all the history, the unsaid things, the specific texture of that relationship written in every track. That knowledge isn’t transferable and it isn’t generatable. It lives in you, accumulated through years of paying attention to a specific human.

You knew their history. You knew what was unsayable between you. Sometimes the tape said it anyway. Sometimes the tape said something you couldn’t say out loud, and you handed it over and watched their face, and they understood.

Spotify can identify that you listened to a lot of sad bastard music in November and serve you more sad bastard music. That’s pattern matching. It’s not the same thing as knowing you well enough to choose badly on purpose. Most mix tapes weren’t made from deep knowing anyway. Plenty were aspirational, or projective, or just an excuse to show off taste. That’s fine. Even thin terrain knowledge beats no terrain knowledge. The algorithm has none.

The intentional misfit is everything.

The song that shouldn’t be there that breaks the mood, that’s too fast or too slow, that’s from a band they think they hate, that’s so on-the-nose it hurts. That is the creative signature. It’s where the maker shows their hand. It’s where intent exceeds taste. The algorithm cannot put that song there. The algorithm optimizes for coherence. The maker optimizes for truth.

The mix tape didn’t have to be the greatest creative act of all time to matter. It was participation. It was showing up in a shared culture of making and giving. The bar wasn’t genius. The bar was thinking about you. That’s low-stakes enough for anyone to clear. High-stakes enough that clearing it actually means something.

The Constraint Was Generative

The modern playlist doesn’t have constraint. Mix tapes did.

Ninety minutes. Two sides. Songs you had to record in real time. The blank tape cost you three dollars. Redoing a side because you botched the timing cost you another hour and sometimes another tape. Every choice had weight because every choice had cost.

We talk about creativity like abundance enables it. More options, more tools, more output, more better. But the mix tape suggests the opposite. The constraint wasn’t a bug. The constraint forced decisions. Every song that made it onto that tape displaced something else. You couldn’t just add it all. You had to choose, and choosing meant committing, and committing meant you were accountable to the thing you made.

Infinite AI output at zero friction is the enemy of that. Not because AI is bad, but because the friction was doing something important. The resistance was where the judgment happened. Where you got better at knowing what you actually thought.

Dave Snowden frames it as the Apprentice Model: automate past the point where humans can do the work manually and you lose the ability to supervise the thing doing it for you. The draft skills atrophy, and atrophied skills make you stupid to when the AI is wrong. The mix tape taught you what a good sequence felt like in your bones. You learned to recognize a bad one.

Even the cover mattered. You drew on it. You picked the one of the four colors on your fat Bic pen for the track list. You added a caption or an inside joke. Ownership through marking, nothing really, technically speaking, but enough for the maker to feel genuine creative agency over the thing. The doodle on the J-card wasn’t decoration. It was a signature. It said: I made this. I made it for you.

You can’t learn terrain from maps. You can study maps until you can recite every contour line. Then you go out there and misjudge a root underfoot, and you learn painfully something the map cannot tell you.

The HITL That Actually Matters

Human-in-the-loop has become a governance term. A safety layer. Someone checks the AI output before it ships. Important. Not unimportant. But fundamentally defensive.

The mix tape reveals something different: the human isn’t in the loop to catch errors. They’re in the loop because the loop is where meaning gets made.

The consequential choices in a mix tape happen inside the maker. Listening, comparing, second-guessing, feeling something shift when the order works, abandoning an idea you were attached to because the tape tells you it’s wrong. That inner process is the loop. The tape is just the output.

The tighter the loop, the more you learn, the more your intent sharpens. Automate it and your intent thins out. Fully close the loop: AI selects, AI sequences, you approve– and the “thinking about you” connection evaporates. The recipient stops feeling thought-about. They feel processed.

AI is inductive: it finds patterns in past data. Human creativity is abductive: it leaps to a hypothesis the data doesn’t contain.

The mix tape was an abductive act. You weren’t extrapolating from the recipient’s listening history. You were making a leap: this song, right here, even though nothing predicted it.

You cannot automate abduction. You can only automate induction.

Confusing one for the other is a slow way to hollow out your soul.

The loop has to be real. A human rubber-stamping AI output at the end of a conveyor belt isn’t a human in the loop. It’s theater at best. You have to have done enough of the manual work to know what good feels like before you hand it off.

If you said “make me a playlist for a breakup” and published what came back, that’s not a mix tape. That’s Spotify with extra steps. The difference isn’t whether AI was involved. The difference is where the judgment lived.

What Creativity Is For

If it’s for producing novel shiny output: AI wins. Unambiguously, at scale, faster, cheaper, tireless. If maximizing the quantity of coherent, useful, well-organized creative product is the goal, AI solves that problem and the humans can go do something else.

But that’s not what creativity is for.

The making does something to the maker. Transformation is the point, not the byproduct.

You’re different after you’ve made a great mix tape than you were before. You know something about the recipient you didn’t know when you started. You know something about yourself. What you were reaching for, what you were afraid to say, what you finally said anyway. The process revealed something the tape alone can’t fully express.

The long slow education of learning to pay attention to specific humans, specific moments, specific things that are true and hard to say. You can’t shortcut it. You can’t compress it. Every mix tape you made, good or bad, taught you something the next one could use. The terrain accumulates. The draft skills build. And when the algorithm fails, you’ll know. Because you’ve been in there, doing the actual thing, long enough to feel it.

When you offload the consequential choices. When the AI selects the songs and determines the sequence and you approve it. You get the tape but not the education. The output looks the same. The maker is unchanged.

You’re a Maker if You Make Choices

I didn’t compose a single song on any mix tape I ever made. Never played an instrument, never wrote a lyric. Still made things that mattered to people. Still made things that said what I couldn’t say out loud. Still took creative risks that could fail. Still learned something every time, good tape or bad.

The creativity wasn’t in the composition. It was in the caring act of curation. The choosing, the sequencing, the marking, the giving. The judgment. The terrain knowledge applied under constraint with something at stake. None of that required a credential. It required showing up and giving a shit long enough to think about someone else.

That’s still available to you. Right now. With whatever tools you have.

The blank tape became a CD-RW became a streaming platform became an AI. What hasn’t changed: somewhere in the process, a bona fide meatspace person has to be doing the creative action. Making consequential choices from a position of genuine knowing. Knowing the terrain, knowing the recipient, knowing what it means when something doesn’t fit but you put it there anyway.

When that’s present, the human soul made the thing, regardless of what tools were involved.

When that’s absent, no tool in the world fills the gap.

The algorithm will never put the wrong song in on purpose. That’s your job. That’s always been yours.

This post was sparked by Kate Compton’s appearance on the Approximately Correct podcast from the Alberta Machine Intelligence Institute (AMII), published March 2026. Compton is a generative artist, researcher, and Assistant Professor at Northwestern University. The Snowden threads draw on his 2025–2026 AI writing series — “Algorithmic Induction,” “Anthropomorphising Idiot Savants,” “A New Animism,” and others — collected at thecynefin.co. Both worth your time.

Last week someone asked if I used AI on a post. The panic on their face said everything. I felt the shame spiral anyway.

Done right, it’s just a tool. This post is about how I make the donuts. It’s not about broad AI ethics or whether AGI will eat us. Just how I use it to say what I mean.

I don’t hide my AI use. But I watch people panic about being caught using it. As if exposure is the sin, not the work. The anxiety isn’t the tool. It’s about being seen.

Here’s My Actual Workflow

Let me walk you through what actually happens when I write a post. Say I want to write about why remote work fails in institutions that worship visibility. This stuff bugs me because I watch it play out in real time. Everyone dials in to prove they were there, even though the meeting made no sense.

Layer 1: Brainstorm & dig

I open a chat: “I want to write about why remote work fails in institutions that worship visibility. What angles am I missing?”

AI comes back with options. I’m not looking for answers. I’m looking for what pings something real in my thinking. Then reverse interview time. I set it up and the AI asks me what I actually think underneath the surface reaction. What’s the real problem? Why does that meeting still bother me? It forces me to stop pretending.

Layer 2: Finding the story

AI asks me for a scenario. I braindump a recent one: the meeting room was half-empty but everyone still dialed in to prove something. Nobody questioned it. The meeting itself was pointless. It could’ve been an email. But visibility mattered more than common sense.

Layer 3: Structure

AI brainstorms four or five angles on the story. I pick one, discard two, push back on the fourth. Back and forth. I’m not following it. I’m using it to find myself.

We figure out the shape. Hook with the pointless meeting. Build tension around why offices still demand physical presence when it serves nothing. Close on what actually matters when you strip away the visibility worship. Storytelling stuff.

Quick sanity check: Am I missing something obvious? Are there logical holes? This is where I fact-check what the AI suggested too. Not exhaustive, just the “did I accidentally write bullshit?” checkpoint.

Layer 4: Outline & draft

AI drafts an outline based on what we’ve figured out. I iterate until it feels like my thinking, not AI-speak. Usually two or three rounds.

Then either I write the post or AI does the shitty first draft. Depends on energy level. Today I’m tired, so AI gets to hold the pen. The result is… fine. It sounds like a “helpful blog guy”, not me. Smooth. Generic. Bloodless.

Layer 5: Voice pass

This is where it becomes mine. I tear through it. Compressed sentences. Word choice. Rhythm. Strip the smooth-sounding stuff. Take a chainsaw to the repetition. Make it sound like I’m talking.

For example: AI drafted “The paradox of remote work is that physical presence becomes performative.” I rewrote it: “Everyone dialed in from the office to prove something.” Same idea. Different blood pressure. One sounds like I’m thinking. One sounds like I’m explaining. I cut two pages down to one. I tighten every metaphor. I kill every qualifier that softens the argument.

This takes an hour. Or more. Worth every minute.

Layer 6: Polish

AI flags readability issues, flow problems, moments that land or don’t. I build a surgical editing plan. Fix this. Keep that (it’s intentional, readers need to sit in it). Ignore that suggestion.

I pick and choose. Some of its feedback is right. Some isn’t.

What This Actually Gets You

I used to spend three hours on structure alone. Now 30 minutes with the AI, then voice and story. The stuff only I can do. My posts are better.

I publish weekly now instead of waiting for inspiration to overcome friction.

The real mark: finished, clear, honest work that actually says what I meant.

What That Colleague Actually Asked

After I told them I used AI, they got quiet. Then: “Wait, so you still write the actual post?”

Yeah. I do the thinking, the outlining, the decisions, the voice pass. The whole thing that makes it mine.

“So you’re just using it like… a tool?”

Yeah. Like spellcheck.

Their whole face changed. The panic dropped. “Oh. Okay. I thought you just fed it a topic and published whatever came out.”

That’s the slop. That’s why people panic. Not because AI is shameful. Because people use it as shortcut and it shows.

No shame. No hiding. Just work.