The automation that actually scales: why a gesture + a script changes how you work on Mac

AppleScript has been around for thirty years on macOS and remains one of the most powerful automation tools on any desktop platform. You can move files, control apps, extract data, send messages, compose emails, interact with the Finder, and chain all of that into arbitrarily complex sequences. There is almost nothing in macOS that AppleScript cannot touch.

And yet, the majority of Mac users — even the most technical ones — never use it habitually.

The problem is not the language. The problem is the last mile.

The bottleneck nobody talks about

When you automate something on your Mac, what you build is not the hard part. The hard part is deciding where that script lives and how you trigger it when you need it.

The usual options are these:

Script Editor saved in some folder. You have to open the app, navigate to the file, and press Run. Useful for scripts you run once. Impractical for day-to-day automations.

Keyboard shortcut via Automator or system service. The global shortcuts system in macOS has constant conflicts between apps. Assigning Cmd+Shift+Option+K to a personal script means remembering a combination that clashes with another app the moment you open something new.

Third-party launcher (Alfred, Raycast, etc.) The experience improves, but you still interrupt the flow: activate the launcher with a shortcut, type the script name, execute it. Three steps for something you wanted to be invisible.

In all cases, the cognitive cost of triggering the automation erodes the benefit of having it. You reach a point where you ask: is the script even worth it if running it requires more mental effort than doing the task manually?

What changes when the access point is a gesture

A cursor gesture requires remembering nothing. It is muscular, not declarative.

Declarative memory — the kind you use to remember keyboard shortcuts — costs cognitive energy. It degrades under pressure. It fails in the weeks after switching apps or updating the system. Muscle memory — the kind a guitarist uses for a chord, or a surgeon for a knot — is different. It is deeper, more resilient, faster.

When a script lives behind a gesture, the trigger stops being a conscious process and becomes a reflex. You do not search for the shortcut in your memory. You simply do it.

The script remains powerful. The access is no longer an obstacle.

The second level: action sequences

An automation that runs a script is useful. An automation that chains multiple actions — scripts, system actions, conditional responses — without human intervention in between, is transformative.

The difference is not one of scale, but of nature.

When you have to run three scripts in sequence to complete a workflow, you are still making three conscious decisions. You are still in the middle of the process. Real automation happens when the entire chain — action A, then B, then C — lives in a single trigger point. One gesture. One result.

Think of a typical workflow in a development environment: close all browser windows related to the previous project, open the environment for the new task, position windows in the correct layout, and start the local server. Those are four distinct operations. With action sequences, they are a single gesture.

The new session starts clean. No friction. Without the three minutes of manual setup that do not add to the real work but consume attention.

Why habitual automation does not scale

There is a pattern in how most Mac users accumulate automations. It starts with a couple of shortcuts. Then they add scripts for the things they do most often. Then they install a third-party tool to manage the scripts. Eventually they have an automation ecosystem that requires its own maintenance.

The system they designed to save time starts to cost time.

The root of the problem is that triggering complexity grows with the number of automations. The more shortcuts you have, the more conflicts. The more scripts you have in the launcher, the more noise to find the one you want. The system that was supposed to disappear becomes visible, and then it no longer works.

Gestures solve this structurally. A gestural vocabulary does not collide. You can have twenty different gestures and none interferes with the next because the space of movement is continuous, not a finite list of key combinations.

What comes next

AppleScript Actions and Action Sequences are planned features on the Curflow roadmap. The first will connect any script — of any complexity — with the gesture system. The second will allow multiple actions to live in a single trigger point.

The goal is automation that works at the speed of thought, not the speed of your memory.

Not because scripting has been simplified. But because access is no longer the bottleneck.