Sometimes people can't immediately size me up, and I can't blame them. After all, I wear a few different hats. That's not to say, however, that each one gets equal use. Far from it. Over the last four years, I have worn two caps more than the others combined. Together, they have paid my bills.

In today's post, I'll explain how my most important lines of business today—writing authors' books and building Notion tools—aren't all that dissimilar.

A Product at the End of the Project

I am not an executive coach or an occupational therapist. My Notion and ghostwriting clients hire me to help them accomplish a defined task. The new CRMs, bespoke event management systems, and physical books all had to meet some definition of done.

Admittedly, that simple, four-letter word can become squishy and contentious, especially on amorphous and flat-rate projects. To minimize confusion and conflict, I bill hourly. The benefits of doing so (avoiding scope creep) more than justify its minor administrative burden. (It's easy to automate time tracking in Notion.)

We Followed Agile Methods

Working on ERP systems for more than a decade taught me the profound limitations of Waterfall development. Of course, I could wait until the very end of the project to show a client a new dashboard, system, or manuscript. The odds that I'll stick the landing are remote, though.

Clients see alpha versions of Notion systems and rough tables of contents. (Ah, the beauty of Scrum.) By definition, they're not perfect. These prototypes provide invaluable directional feedback and minimize the risk of forthcoming surprises, frustration, and wasted time and money. If we're on the wrong track, we quickly find out, make necessary adjustments, and get on the same page.

Mutual Learning

The projects have varied considerably in many ways, but two things have happened on each one:

1. I've learned a great deal about my clients' needs and areas of expertise.
2. They've learned a considerable amount from me.

It's fair to call the transfer of knowledge symbiotic. My clients wouldn't have been able to complete their projects without their input and vice versa.

Unanticipated Delays

Never has even a medium-term engagement gone off without a hitch. At one extreme, a client vowed to follow up with me next week. I finally heard back from him a few weeks later. At the other, a ghostwriting client needed to pause her project for three months.

A New Respect for the Importance of Process

At the beginning of each project, I explain that no decision is irrevocable. Some bells, though, are harder than others to unring. Case in point: changing database structures and reorganizing book sections involves a great deal of rework. Intellectually, that statement is facile, but I make that key point several times before we sign anything. To use a housing metaphor, I ask them to triple-check if we're building a Colonial.

In a few cases, a client and I have reached the point of no return and the former has inexplicably reversed course. (“Yeah, I want a duplex now.”) Demolishing the foundation is expensive, and the burnt hand teaches best.

If we're on the wrong track, we quickly find out and make necessary adjustments.

Brass tacks: each of my clients has walked away with a heightened appreciation for our process.

Feedback

Do you see parallels between different lines of your business? What say you?

At its recent developer conference, Notion announced a powerful new way to extend the application. Still in beta, Notion Workers let users do many interesting things. In the company's words:

Workers are isolated sandboxes managed by Notion, so the code behind your syncs, tools, and workflows runs on our infra(structure) instead of your servers.

Most intersting to me: the ability to sync data from third-party systems. For example, say that your organization runs Salesforce as its CRM. Workers make it relatively easy to bring that data into your Notion workspace for additional analysis and tracking.

I've spent a good deal of time noddling with the new sync capability. Claude Code helped me navigate the new Notion CLI and run some tests with a simple Google Sheet. In today's post, I'll share some of the things I've learned so far.

Long story short: Workers aren't perfect, but they're remarkable. I suspect that over the next year I'll be doing more with them for my Notion clients.

Table of Contents

• Project & Worker Management
  • Useful CLI Reference Commands
  • Directory Context Matters
  • Finding Project Directories
  • Identifying a Worker's ID
  • Renaming a Worker
  • Deleting a Duplicate Worker
  • Code Reuse Across Workers
• Syncing
  • Triggering a Manual Sync
  • Finding the Correct Sync Key
  • Diagnosing a Sync That Runs But Writes Nothing
  • Diagnosing a Runaway Sync Loop
• Schema & Data
  • Adding a New Property to a Synced Database
  • Changing a Property Type
  • Replace Mode Only Manages Worker-Created Records
  • Identifying Read-Only vs. User-Defined Properties
  • Two-Way Sync
• Deployment & Debugging
  • TypeScript Compilation Errors During Deploy
  • Debugging Failed Deploys

Project & Worker Management

Useful CLI Reference Commands

Directory Context Matters

The ntn CLI resolves the target Worker from the workers.json file in the current directory. Always cd into the correct project folder before running Worker commands. Running commands from the wrong directory targets the wrong Worker or fails entirely.

cd /Users/your_drectory

Finding Project Directories

To locate all Worker projects on your machine:

find ~ -name "workers.json" 2>/dev/null

Identifying a Worker's ID

To find the Worker ID tied to a specific project directory:

cat /path/to/project/workers.json

The workerId field is the canonical identifier for that Worker.

Renaming a Worker

The CLI lacks a dedicated rename command. The display name derives from the name field in package.json. Update that field and redeploy to rename the Worker. The sync capability key — which you define in src/index.ts — is independent of the display name and continues to work without modification.

Deleting a Duplicate Worker

With two Workers sharing the same display name, confirm which ID belongs to the unwanted one via workers.json, then delete it:

ntn workers delete <worker-id>

Code Reuse Across Workers

Once you build a working Worker, save it as a GitHub repo or template. The Worker structure, deploy flow, and Notion API calls transfer to future projects. Swap out the data source and schema — the scaffolding stays intact.

Syncing

Triggering a Manual Sync

To bypass the schedule and trigger a sync immediately, run the following from your Worker project directory:

ntn workers sync trigger <syncKey>

The sync key is the string passed to worker.sync("...") in src/index.ts — it may differ from the Worker's display name in the Notion UI.

Finding the Correct Sync Key

If you don't know the sync key, run this from the project directory:

ntn workers capabilities list

This returns the exact key and type for every registered capability.

Diagnosing a Sync That Runs But Writes Nothing

All runs showing exit code 0 with no database changes usually means an incremental sync has recorded state and sees no new data. Reset the state to force a full re-fetch:

ntn workers sync state reset <syncKey>
ntn workers sync trigger <syncKey>

Diagnosing a Runaway Sync Loop

If the runs list shows dozens of executions firing every few seconds, you've set the schedule option in src/index.ts too aggressively (such as "continuous" or "1m"). Change it to "1h" (or another appropriate interval) and redeploy:

ntn workers deploy

Left unchecked, a runaway sync burns through Worker credits rapidly.

Schema & Data

Adding a New Property to a Synced Database

Adding a column to the Google Sheet does not automatically add it to Notion. The Worker only syncs properties explicitly defined in src/index.ts. Two changes are required:

1. Add the property to the schema block:

schema: {
  properties: {
    Descr: Schema.title(),
    Code: Schema.richText(),
    NewProp: Schema.richText(), // add here
  },
},

1. Add the property to the mapping inside execute:

properties: {
  Descr: Builder.title(row[1] ?? ""),
  Code: Builder.richText(row[0]),
  NewProp: Builder.richText(row[2] ?? ""), // add here
},

Then redeploy and resync:

ntn workers deploy
ntn workers sync state reset <syncKey>
ntn workers sync trigger <syncKey>

Changing a Property Type

Changing a property's type in src/index.ts (such as from Schema.richText() to Schema.number()) does not convert the existing property in Notion. Notion keeps the original type.

The fix: rename the property in src/index.ts to force Notion to create a fresh property with the correct type. The old property remains but sits empty — hide it from your views.

Replace Mode Only Manages Worker-Created Records

The Worker's replace mode mark-and-sweep only tracks and removes records it created. Records added manually in the Notion UI don't carry the Worker's internal tracking metadata, so the sync leaves them alone — even if they don't exist in the external source.

If orphaned manual records appear in a managed database, delete them directly in Notion. They won't be cleaned up automatically.

Identifying Read-Only vs. User-Defined Properties

Notion provides no visual indicator distinguishing synced (read-only) properties from user-defined ones. The reliable method: open a record and try to edit a field. Synced Worker properties are locked. User-defined properties accept edits.

From the code, read-only properties carry readOnly: true in the data source schema — these map directly to columns in the external source. Any property you add to the Notion database outside the Worker schema (such as a Status or ID field) remains fully editable and the sync won't touch it.

Two-Way Sync

Workers syncs are one-way by design: external source → Notion. To push Notion changes back to an external source, build a second Worker using worker.webhook(...). The flow:

1. The second Worker registers a webhook endpoint and gets a URL on deploy.
2. A Notion database automation triggers on page changes and fires a POST to that URL.
3. The webhook handler reads the payload and writes the change to the external source (such as Google Sheets via its API).

The Notion-side plumbing transfers to any external source. The external API client and auth (such as OAuth for Google Sheets) require rewriting per source.

Deployment & Debugging

TypeScript Compilation Errors During Deploy

A failed deploy (exit code 2) means the TypeScript compiler rejected the code. The error appears directly in the Terminal output when you run ntn workers deploy. Always read that output before troubleshooting elsewhere.

Common example: Builder.number() does not accept null. Use a numeric fallback instead:

// Wrong
Num: Builder.number(row[2] ? parseFloat(row[2]) : null)

// Right
Num: Builder.number(parseFloat(row[2] ?? "0") || 0)

Debugging Failed Deploys

Use ntn workers runs list to check exit codes. A deploy with exit code 2 failed — any sync runs after it use the last successful build, not your latest code. The full error appears in the Terminal output of ntn workers deploy itself, not in the run logs.

If I've learned anything in three decades working with enterprise tech, it's this:

The older the organization, the worse its systems are likely to be.

Call it Simon’s First Law of Enterprise Systems. Since I like graphs:

Is the law absolute? Of course not. I've seen small organizations and startups immediately screw up their new systems. Plenty of larger ones run tight ships. On balance, though, Simon's First Law holds up. (Why New Systems Fail contains plenty of studies to this effect.)

Car Insurance Chaos

Case in point: I recently switched car insurance companies. We'll call the new one ABC here. (Fun fact: The real outfit set up shop in 1864.)

After pulling the trigger, the following happened over the next week:

• ABC kept sending me updates on my initial quote—again, after I purchased the policy. (I can only imagine what type of antiquated CRM it's running.)
• I could not access my new policy on either ABC's website or in its primite iOS app. Customer service advised me that its systems (plural) weren't working for new customers. You know, the ones most likely to cut bait.
• Making matters worse, ABC's iPhone app didn't support Apple Wallet, a tool that arrived in 2012. Save a photo and nervously try to find it when pulled over like it's 2007.
• To track my mileage and safe-driver discount, I would have to regularly snap photos of my car's odometer and send them to ABC. (By contrast, consider my previous insurance provider, Lemonade. It let me plug a simple dongle into my automobile's OBD-II port. No photos and uploads necessary.)

Within a week, I canceled my coverage and returned to Geico. True to form, ABC sent me a reminder for my active quote the next day. (You just can't make this stuff up. Maybe it sent more, but I added some code to my sophisticated Fastmail filters.)

Simon Says: I dodged a bullet.

In a way, I'm happy that I experienced this level of tech ineptitude with ABC right out of the gate. Things would have been much worse if another car had hit mine or vice versa months or years down the road.

Give ABC credit for lasting so long. If it doesn't fix its enterprise systems and mobile app soon, though, its days as a viable independent entity are numbered.

Last year, I fired up Relay.app to automate a key process I had been completing manually. (I'll keep the specifics to myself here.) A few minutes of work saved me probably a few hours in the past twelve months. It all ran like clockwork.

I woke up the other day to find this email in my inbox:

I suspect that the software vendor cut off or restricted access to its API. Relay.app and its users were casualties.

Once you've automated an important manual process, who wants to revert? Not this geek. In today's short post, I'll explain how Claude Code and I built a better mousetrap.

Searching for Alternatives

When I asked Claude Code what I should use as a Relay.app replacement, it logically spit out the similar no-code tool n8n. Before continuing, I questioned its recommendation (as you always should with any AI). What's to stop Vendor X from doing the same to n8n next week or next year?

Precisely nothing.

A little research and trial-and-error with Claude Code revealed that no current API would allow me to do what I wanted. Undeterred, I suspected that we could write a Python script that calls the Playwright automation library. After all, that approach has paid dividends over the last few months. (Again, I'm being intentionally vague here.)

A little critical thinking goes a long way.

I invoked the insanely useful /grill-me skill and confirmed the viability of the Python/Playwright approach. Claude Code and I then went to work. In a single session lasting 45 minutes, we cooked up a new, more robust automation.

Simon Says

My newfangled Python/Mac solution works, but it probably isn't permanent. Code breaks. At some point in the future, there's a good chance that I'll have to perform some maintenance on it.

This little yarn demonstrated, though, the power and variety of tools available to curious citizen developers. Once again, no API? No problem.

Last week I used NotebookLM to generate two podcasts based on Chapter 1 of my book Low-Code/No-Code. In today's post, I'll continue my experiment by asking it to generate a brief explainer video of the same book.

Let's light this candle.

The Prompt

In the same notebook I created last week, I prompted Google's sophisticated AI tool and included the link to the book.

Here's NotebookLM's result:

Decent video, but it focuses solely on the excerpt I had uploaded last week. Put differently, I gave the AI explicit instructions to create a video covering the whole book and the link to the Amazon page. Instead, NotebookLM opted to concentrate only on the first chapter.

AI still routinely fails to make obvious calls

I could pick nits for another hour or so, but here's another biggie: the cover includes the word excerpt. I was curious to see if it would correct the mistake or repeat it. Ideally, NotebookLM would remove the word—or at least call out the current cover image and ask me if I wanted to keep it as is. Any video editor worth her salt would.

Attempt #2

I then made my prompt as specific as possible:

This is the second video NotebookLM generated:

Better than the first attempt, but hardly perfect. Again, the cover in the video includes the word excerpt. Also, the design is a little inconsistent. Next up, as my speaking clients know, I'm not a fan of displaying complex visuals while the narrator is talking.

Brass tacks: NotebookLM's videos are nowhere near as professional as the book's proper trailer. Judge for yourself.

Note the trailer's color and style ubiquity. The free, AI-generated ones just don't compare to the final, human-made version.

Simon Says

Could I have spent more time finagling with NotebookLM? Of course, but there are limits to my geekdom. For now, just remember two things. First, with AI, you get what you pay for. Authors are better off omitting an explainer video from their marketing materials than creating a cheap one that tarnishes their brands.

Second and more generally, AI still routinely fails to make obvious calls. NotebookLM proved as much by twice ignoring the word excerpt. Don't expect that reality to change anytime soon.

Readers of my site know that I'm all in on Claude. That doesn't mean, though, that we're in an exclusive relationship. As I recently wrote, foolish are the souls who only carry one AI club in their bags.

Against that backdrop and inspired by Joanna Stern's hysterical new book I Am Not a Robot: My Year Using AI to Do (Almost) Everything, I decided to noodle a little more with Google's NotebookLM.

Going From Text to Audio

Yesterday, I launched Notebook LM and promptly uploaded Chapter 1 of Low-Code/No-Code: Citizen Developers and the Surprising Future of Business Applications. (Download the original PDF excerpt here.) I then gave it the following prompt:

Half an hour later, NotebookLM dutifully spit out two professional, twentyish-minute interviews of topics discussed in that chapter. The final products are anything but robotic. Rather, they sound remarkably natural with the occasional vocal tic.

Here they are, along with their AI-generated descriptions.

Broken IT Departments

Trillions Spent

A Minor Modification

Ultimately, I wanted these AI-generated conversations to live here. The only issue: unnecessarily large file sizes. Each .wav file ran about 40 MB. Before uploading them to Cloudflare and embedding them here, a little shrinkage was in order. (Cue obligatory Seinfeld reference.) Claude Code wrote the Terminal code to shrink them.

True to form, Claude's Terminal command considerably shrunk each file.

Simon Says: AI jargon is everywhere, but expect this term to stick.

I could quibble a bit with the results, but NotebookLM's output impressed the hell out of me. Even three years ago, transforming even raw text—much less a sophisticated PDF—into audio of this quality would have taken much, much longer.

This simple example illustrates the unprecedented power of today's AI tools. They are truly new, and it's no coincidence that use of the term multimodal is spiking. Unlike much AI jargon, expect this one and AI slop to stick.

how can i navigate the dizzying future of work?

Check out my award-winning book, The Nine: The Tectonic Forces Reshaping the Workplace.

BUY THE BOOK

In the 1996 flick Tin Cup, volatile golf pro Roy McAvoy routinely melts down. One particularly memorable scene involves Kevin Costner's character destroying all the clubs in his bag, save for his precious 7-iron. He then proceeds to par the back nine of the course he's playing using only that club.

Say what you will about McAvoy. By the end of the film, you're rooting for him.

I was thinking about that movie in the context of AI tools. In today's post, I'll explain why your bag should contain an array of clubs.

When Simple Becomes Complicated

Notion custom agents can do some downright remarkable things. Sadly, though, they can't always accurately and reliably handle what should be straightforward tasks. (Not for the first time, either.)

Case in point: I'm currently working with an author to conceptualize her second book. To this end, I wanted to quickly create a new shell of RacketHub—my comprehensive, Notion-based book-management system. My goal was simple: to change the default page and database prefixes from the generic RH to the author's initials. Doing so also helps me keep my sanity when working with multiple clients.¹

Let me make the example more concrete. Take the dedicated book covers database—RH37:

Manually changing the database prefix from RH to any two letters—such as SH—takes two seconds. Editing dozens of other databases and pages, though, takes real time. The rote process screams automation. It would be simple to set up a Notion custom agent or prompt Notion AI.

Boy, was I wrong.

Spend enough time around consumer and enterprise tech and you'll encounter the following problem: a software vendor's wares don't work as described. It's inevitable. Support calls, screen-sharing sessions, Reddit posts, chats with AI tools, and a tsunami of emails all fail to resolve your issue.

That scenario is typical. On rare occasions, however, something remarkable happens: the vendor support rep admits that you're right. That is, your problem is no PICNIC.

Is Maybe the company eventually issues a patch that resolves your issue; maybe it doesn't. Over the years, I have seen Apple, Microsoft, and Notion admit that relatively minor bugs existed in their software, but their engineers wouldn't be addressing them anytime soon. If hundreds of millions of people use your products, you can't make everyone happy.

Previous Alternatives for Non-Coders

In the past, options everyday folks included:

• Find a new solution, but vendor lock-in served as a formidable deterrent.
• Adjust how you work to account for the current limitation.
• Adopt a low-tech solution, such as pen and paper.

These choices weren't exactly satisfying. Today, though, citizen developers can pick up a new in their bags: vibe coding.

Last July, I wrote about the AI tool that blew my mind. To be sure, model context protocols still let citizen developers do powerful things. Sadly, though, they waste oodles of tokens in the process. Even the company that invented MCPs (Anthropic) admits as much. (Some have equated the process to reading the encyclopedia before answering a question someone has asked you.)

In the ten months since I wrote that post, Claude has added oodles of features. What's more, the developer community has been busy. (Hell, even I released a neat public GitHub repo.)

One of the buzziest open-source projects today is Printing Press. Think of it as a library of bespoke command-line interfaces (CLIs) that anyone can use in myriad ways. (As its name implies, you can also roll your own.) In this post, I'll explain on way in which generative AI is breathing new life into this decidely unsexy UI.

Burning Basketball Questions

As my site's readers know by now, I'm an avid basketball fan. I'll often check ESPN NBA box scores to see which players performed well and which did not. (Wemby's numbers never cease to amaze me.)

Basic site searches are easy enough. If I wanted to ask more complicated basketball questions, though, I'd have to get creative. First, I'm no developer. Second, ESPN discontinued its API in December 2014.

Enter Printing Press.

I launched Claude Code and installed its ESPN CLI Skill. Here's my initial prompt to it requesting data on James Harden—the Cleveland Cavaliers' well-traveled starting point guard.

Four years ago, I purchased a new leather recliner from an outlet called The Dump for a little over $1,000. (If the name suggests foreshadowing to you, trust your instincts.) Importantly, I opted for the five-year extended warranty.

Fast-forward to early 2023. The side latch on the side snapped off during normal use, making reclining impossible. I dutifully submitted a claim to AllProtect, the third party The Dump contracted to handle post-purchase maintenance. A repairman visited my home about a week later and replaced the broken latch. Let the lounging resume!

Or so I thought.

Groundhog Day

About 18 months after that, the same thing happened. Can someone say Groundhog Day? I wasn't happy, but that same knowledgeable technician visited me. Thirty minutes later, we were good to go.

Yesterday I sat down to do my morning NY Times puzzles and—you guessed it—the same latch busted again. That's thrice I had to navigate a chain ostensibly designed to frustrate unsuspecting customers.

I wanted to see if my go-to Claude could effectively visualize and interpret the issue. Here are the results:

You won't find many bigger fans of generative AI than yours truly—and Claude in particular.

Plenty of learned folks believe that single-purpose tools, like note-taking apps, will go the way of the dodo. In short, I agree. I'm on record predicting most niche software vendors will go poof in the near future. But what about enterprise systems? In this post, I'll explain why most of them will survive.

How Are You Using That App?

I will never claim to be an expert on every task management, productivity, and note-taking app out there. Popular choices include Coda, Bear, Obsidian, and Todoist. I do, however, know a thing or six about Notion. For the sake of argument, say that the Notion universe consists of only two groups: basic and power users.

Group #1

A software vendor's app relies heavily on casual users. The majority of these folks use it in a limited way. Maybe 70 percent of people just scribble down the occasional idea in the note-taking app.

You needn't be a sorcerer to know how this movie ends: Claude Cowork and similar tools will make these simple apps obsolete. (Zapier, Make.com, and other third-party glueware are in similar boats.)

Group #2

Now let's move to power users. I'm talking about people who use the app or system for much more than taking notes. Notion performs dozens of functions for folks in this cohort. Claude, ChatGPT, Gemini, or one of their competitors will ultimately cannibalize such a versatile tool anytime soon.

For Notion power users, the idea that a newfangled AI tool can replace it is absurd.

Now, let's kick it up a level: If a single individual is unlikely to supplant Notion with Claude, then will even a medium-sized enterprise forgo its core systems?

want to learn more about citizen development?

Check out my 2023 book Low-Code/No-Code: Citizen Developers and the Surprising Future of Business Applications.

BUY THE BOOK

A Key Software Distinction

Generative AI tools are inherently non-deterministic. Sure, they'll continue to improve, reduce hallucinations, and ultimately reduce tool sprawl.

By contrast, CRM and ERP systems of record are deterministic. They are far too important to leave to chance. “I usually want to get employees' checks right,” said no payroll manager ever. What's more, these vendors behind these enterprise systems recognize the need for their wares to evolve.

CRM and ERP systems won't disappear.

Connecting the dots leaves one answer: enterprise systems will certainly morph. In particular, their UIs will undergo massive makeovers. It's folly, though, to think that they'll completely disappear. And plenty of others feel the same way.

Simon's Law of AI Disruption

The more diverse the software, the more likely it is to survive the AI tsunami.

Feedback

What say you?

Perhaps no technology in history has morphed quicker than generative AI. Hell, a week seems like a year for a single company. Even if you spend a good deal of time teaching yourself how to use newfangled tools, it's virtually impossible to keep up.

Against this backdrop, no-code automation giant Zapier recently made news by releasing the second iteration of its AI fluency rubric. TL;DR: If you don't embrace AI, don't bother applying for a job. (Zapier is hardly alone here. Meta grades its workers on their degree of “AI nativeness.”)

Observations

Zapier's post is thoughtful and well-written, but you won't find anything meaningful about how employees can level up their AI proficiency. Noticeably lacking are specifics on any of the following:

Not that long ago, the decision of which application or system to use was typically a no-brainer.

Take the early aughts. Back then, you'd be silly to create a training manual in anything but Microsoft Word. You wouldn't think twice. Ditto for PowerPoint—the de facto standard for presentations. We performed ad hoc data analyses in Excel. You could eschew Salesforce because you preferred your bespoke Microsoft Access CRM. (That choice, though, probably didn't sit well with your boss.) Google's productivity apps worked similarly. You get my drift.

Brass tacks: Only an amateur would use a screwdriver to hammer a nail into the wall.

What about today?

The rise of GenAI has muddied the waters. In today's quick post, I'll offer a few tips on how Claude users can successfully navigate this new world.

Prompt #1

When I begin a new task or project of consequence, I prompt Claude as follows via a Raycast snippet:

When it comes to embracing new technologies, I've always been an early adopter. My friends in grad school still fondly remember my exuberance over the nascent web.

I'll take the Pepsi challenge against anyone. (Thank you, Carnegie Mellon.) At the same time, though, I have to admit: I'm struggling to keep up with Anthropic's crazy pace of innovation.

Recent Additions

As I write these words, here are just some of the features the company has dropped in the last few days:

1. The ability to fully control your computer on whatever device you like—subject to a few caveats. (Cool, but yikes!)
2. Claude Cowork Projects.
3. Claude Code Channels.
4. Memory 2.0.
5. Auto mode to grant or restrict Claude Code's access on your computer. (It's a safer alternative to --dangerously-skip-permissions.

To be fair, you may not have seen any or all of these new releases just yet for whatever reason. Possible culprits include:

• Anthropic's gradual rollout of the feature.
• The responsibilities of your day job.
• A plan restriction.
• A combination of all three.

Maybe it's something else.

Hell, by the time you read these words, Anthropic may have released two more insanely useful capabilities.

Unexpected UI Changes

Yesterday, I was testing Claude's cool new Dispatch feature when I noticed a lightbulb icon in Claude Cowork:

I went all Krusty the Klown:

Even Claude couldn't confidently give me an answer. Here's my prompt:

Reply:

Likely shows. Even Anthropic's own chatbot can't keep up with its torrid pace of innovation.

Looking at the Data

Always curious, I looked at the Claude Code changelog and asked my AI bestie to visualize the number of recent changes in that tool alone. In other words, I omitted Claude Cowork, vanilla Claude, and change Anthropic classified as a fix. Here's the breakdown:

Claude Code Recent Features by Day

Source: Anthropic | For some reason, Claude omitted changes after March 21.

Of course, some enhancements are more meaningful than others. Still, nary a weekday goes by without something new appearing in the Claude suite of tools.

Simon Says

If I have learned anything over my three decades in enterprise technology, it's this: Tech typically moves much faster than people and organizations can handle. The rise of AI in the last few years reflects that reality in spades.

Is it possible to keep a workforce current on tools that change by the day?

No one is more critical of organizations failing to train their employees properly on new tools than I. (It's a key point in Project Management in the Hybrid Workplace.) At the same time, however, is it possible to keep a workforce current on tools that morph by the day?

In a word, no.

On the diamond, we call individuals who can effectively play more than one position utility players. Fun baseball fact: five people have played all nine in a single game.

I was recently thinking about this term in the context of AI because Claude helped me solve four very different problems before lunch.

Mixologist and Grocery Store Attendant

I know nothing about mixing drinks—even two-ingredient ones. At least I'm self-aware enough to ask Claude: