Perspective Cuts: Code Your Apple Shortcuts in Text

What if I told you that every minute you spend dragging colorful blocks around in Apple's Shortcuts app is a minute you could have spent writing actual code?

If you're a developer — or even just someone who thinks in text rather than visuals — the Shortcuts app feels like a toy. A beautiful, polished toy, but a toy nonetheless. You've got muscle memory for Vim. You live in your terminal. Your .zshrc is a work of art. And then Apple wants you to drag a "Get Current Weather" block onto a canvas and tap through menus to configure it?

There's a better way. And it's not some janky workaround or abandoned side project.

Enter Perspective Cuts — a text-based language for writing Apple Shortcuts that compiles directly to signed .shortcut files. No Electron wrappers. No web apps. No third-party signing services. Just pure Swift, Apple's own shortcuts sign command, and the terminal workflow you already love. This is the tool that makes Apple's automation platform finally feel like it was built for people who actually write code.

Ready to stop playing with blocks and start building? Let's dive in.

What Is Perspective Cuts?

Perspective Cuts is an open-source, experimental compiler created by Taylor Arndt that transforms text files into fully functional Apple Shortcuts. Built entirely in Swift using Swift Package Manager, it runs exclusively on macOS and produces signed .shortcut files compatible with macOS, iOS, and iPadOS.

The project's philosophy is refreshingly direct: write code, compile it, get a shortcut. No visual editor. No drag-and-drop abstraction. Just a clean, text-based language that feels natural to anyone who's written Swift, Python, or JavaScript.

Why does this matter now? Because Apple's Shortcuts ecosystem has exploded in complexity. With iOS 26, we got Apple Intelligence actions, Private Cloud Compute integration, new Writing Tools, and an ever-expanding catalog of third-party app integrations. Yet existing code-based solutions like JellyCuts have fallen behind — their action libraries are outdated, they lack support for modern AI features, and they can't tap into arbitrary third-party apps without manual registration.

Perspective Cuts solves all of this. It ships with 180+ built-in actions using friendly parameter names, supports any third-party app action via raw identifiers, and leverages Apple's own signing infrastructure. The creator's stance is clear: this is a Mac tool built the right way, using Apple's official channels rather than hacks or workarounds.

The project is currently highly experimental — APIs change, actions may break, and only 35 actions have been fully tested end-to-end. But the compiler works, the language is expressive, and the foundation is solid enough for serious experimentation.

Key Features That Make Perspective Cuts Insane

Let's break down what makes this tool genuinely powerful for developers who want to automate without sacrificing their workflow:

180+ Built-In Actions with Developer-Friendly Names

Instead of memorizing Apple's internal action identifiers, you write text(text: "Hello") or showResult(text: output). The language abstracts Apple's verbose API into clean, readable function calls that map directly to Shortcuts actions you already know.

Any Third-Party App Action, Zero Registration

This is where Perspective Cuts pulls ahead of everything else. Want to trigger ChatGPT, Drafts, Fantastical, Bear, or Things? Just use the raw bundle identifier: com.openai.chat.AskIntent(prompt: question). No registering apps with a service. No waiting for maintainers to add support. If the app is installed on your Mac, you can call it.

Apple Intelligence & Private Cloud Compute

The tool supports cutting-edge AI features that competitors simply don't have yet. You can invoke on-device models, Private Cloud Compute, and the new Writing Tools — all from text files that compile to native shortcuts.

Full Control Flow

Write real programs, not just linear action chains. Perspective Cuts supports if/else conditionals, repeat loops, for-each iteration, and menu branching. Your shortcuts can finally have logic that doesn't require nesting blocks until your screen is a rainbow spaghetti nightmare.

Signed Output That Apple Trusts

The compiler uses shortcuts sign — the exact command Apple ships with macOS for signing shortcut files. Your compiled .shortcut files are legitimate, verified, and work seamlessly across all Apple devices. No sketchy third-party certificates. No "untrusted shortcut" warnings.

Discovery Tools for Exploration

The discover and detail CLI commands let you introspect any installed app's actions, inspect their parameters, and understand how to invoke them — all from your terminal.

Real-World Use Cases Where Perspective Cuts Dominates

1. AI-Powered Content Workflows

Imagine subscribing to 15 Substack newsletters and wanting a daily digest. With Perspective Cuts, you write a shortcut that fetches RSS feeds, sends the content through Private Cloud Compute for intelligent summarization, and delivers bullet-point summaries to your lock screen. No visual editor could handle this complexity gracefully.

2. Cross-App Automation Without Limits

Your note-taking app (Bear), calendar (Fantastical), task manager (Things), and AI assistant (ChatGPT) all need to talk to each other. Instead of building fragile URL scheme chains or waiting for official integrations, you write one text file that orchestrates everything. The discover command finds the exact identifiers you need.

3. Reproducible Shortcut Development

Teams and open-source projects can version-control their shortcuts. Need to update a workflow across 50 devices? Push a .perspective file to Git, let CI compile it, and distribute the signed output. Try doing that with a visual canvas.

4. Accessibility-First Automation

The creator explicitly built this because drag-and-drop interfaces don't work for everyone. Screen reader users, keyboard-navigators, and anyone who finds visual programming cognitively taxing can now build powerful shortcuts with the same tools they use for everything else.

5. Rapid Prototyping for Power Users

Need to test five variations of a shortcut? Copy-paste your .perspective file, tweak parameters, recompile in seconds. The visual editor would have you rebuilding from scratch every time.

Step-by-Step Installation & Setup Guide

Getting started with Perspective Cuts takes under two minutes if you have Homebrew installed.

Method 1: Homebrew (Recommended)

# Add the custom tap
brew tap taylorarndt/tap

# Install the compiler
brew install perspective-cuts

This gives you the perspective-cuts command globally, ready to use from any directory.

Method 2: Build From Source

# Clone the repository
git clone https://github.com/taylorarndt/perspective-cuts.git

# Enter the project directory
cd perspective-cuts

# Build with Swift Package Manager
swift build

Building from source is ideal if you want to contribute, need the absolute latest commits, or prefer not to use Homebrew.

Verifying Your Installation

# Check the tool is available
perspective-cuts --help

# List all built-in actions
perspective-cuts actions

# Discover third-party apps with actions
perspective-cuts discover --third-party

System Requirements

• macOS only — The shortcuts sign command is Apple's macOS-exclusive tool
• Swift toolchain (included with Xcode Command Line Tools)
• No iOS support unless Apple releases an official signing tool

REAL Code Examples From the Repository

Let's examine actual code from the Perspective Cuts repository, with detailed explanations of how each piece works.

Example 1: Hello World — The Basics

# Write a shortcut file using a heredoc
cat > hello.perspective << 'EOF'
import Shortcuts
#color: blue
#icon: star
#name: Hello World

text(text: "Hello from Perspective Cuts!") -> greeting
showResult(text: greeting)
EOF

# Compile and cryptographically sign the output
swift run perspective-cuts compile --sign hello.perspective

# Open the resulting file in Shortcuts app for immediate use
open hello.shortcut

What's happening here? The .perspective file starts with import Shortcuts to bring in the action library. Metadata directives (#color, #icon, #name) configure how the shortcut appears in the Shortcuts app. The text() action creates a string, and the -> greeting syntax assigns it to a variable named greeting. Finally, showResult(text: greeting) displays that variable. The --sign flag invokes Apple's shortcuts sign command, producing a trusted .shortcut file.

Example 2: Substack Summarizer with Private Cloud Compute

import Shortcuts
#color: purple
#icon: compose
#name: Taylors Substack Summarizer

# Fetch the latest 5 items from an RSS feed
getRSSFeed(url: "https://taylorarndt.substack.com/feed", count: 5) -> feedItems

# Send to Apple's Private Cloud Compute for intelligent summarization
useModel(
    prompt: "Summarize each of these blog posts in 3 key bullet points:\n\(feedItems)",
    model: "Private Cloud Compute",
    resultType: "Automatic",
    followUp: false
) -> summary

# Display the result
showResult(text: summary)

The power here is extraordinary. This shortcut fetches live RSS data, pipes it through Apple's most secure AI infrastructure (Private Cloud Compute keeps your data encrypted and ephemeral), and returns structured output — all in nine lines of readable code. The \(feedItems) syntax is string interpolation, familiar from Swift. The useModel action demonstrates how Perspective Cuts exposes cutting-edge Apple Intelligence features that visual Shortcuts users are still figuring out how to configure.

Example 3: Third-Party Integration (ChatGPT)

import Shortcuts
#color: green
#icon: message
#name: Ask ChatGPT

# Prompt the user for input
ask(prompt: "What do you want to ask ChatGPT?") -> question

# Call ChatGPT's native Shortcuts action using its bundle identifier
com.openai.chat.AskIntent(prompt: question) -> answer

# Display the AI's response
showResult(text: answer)

This reveals the raw identifier system. Instead of waiting for Perspective Cuts to "support" ChatGPT officially, you use com.openai.chat.AskIntent — the exact bundle identifier ChatGPT exposes to Shortcuts. The discover command finds these for any installed app. This is fundamentally different from other code-based tools that require maintainers to hardcode every supported app.

Example 4: CLI Workflow — Discovery and Inspection

# Find all actions from apps with "openai" in their name
perspective-cuts discover openai

# Inspect the exact parameters ChatGPT's action expects
perspective-cuts detail com.openai.chat.AskIntent

# Validate your .perspective file without compiling
perspective-cuts validate myshortcut.perspective

# Compile and install directly to Shortcuts database (no manual import)
perspective-cuts compile --install myshortcut.perspective

The CLI is where developers live. The discover command eliminates guesswork for third-party apps. The detail command shows parameter names, types, and options — like man pages for Shortcuts actions. The validate command catches syntax errors before you attempt compilation. And --install skips the manual "Open in Shortcuts" dance entirely.

Advanced Usage & Best Practices

Master the Discovery Workflow

Before writing any third-party action, run perspective-cuts discover <keyword> and perspective-cuts detail <identifier>. This prevents parameter mismatches and reveals hidden options the visual editor obscures.

Version Control Your Shortcuts

Treat .perspective files like source code. They're plain text, diff-friendly, and perfect for Git. Create a shortcuts/ directory in your dotfiles repository and never lose a workflow again.

Handle Known Limitations Gracefully

The compiler has documented edge cases. changeCase is unavailable because case is a parser keyword — use workarounds or file an issue. getCurrentWeather only works on iOS, so gate it behind device detection. Some enum parameters need integer values rather than strings; check the language reference.

Leverage String Interpolation Heavily

The \(variable) pattern lets you construct complex prompts, URLs, and messages dynamically. Combine multiple action outputs into rich, contextual inputs for AI actions.

Test on Target Devices Early

While compilation happens on macOS, test the resulting .shortcut files on your actual iPhone or iPad. Action availability varies by OS version, and some third-party apps have iOS-specific behaviors.

Comparison With Alternatives

The verdict? If you want a code-based workflow with modern action support and no compromises on security, Perspective Cuts is the only option that checks every box. JellyCuts pioneered the space but hasn't kept pace with Apple's evolution. Scriptable is powerful but lives in a different paradigm entirely.

FAQ

Q: Is Perspective Cuts stable enough for daily use?

A: It's experimental — 35 actions are fully tested, 167 have verified identifiers. The compiler and language are solid, but expect edge cases. Don't build mission-critical medical workflows yet; do automate your morning routine with confidence.

Q: Why macOS only? Will iOS support come?

A: Apple only ships shortcuts sign on macOS. The creator refuses to use unofficial signing methods on principle. If Apple releases an iOS signing tool, iOS support will follow immediately.

Q: How do I find the bundle identifier for my favorite app?

A: Use perspective-cuts discover <keyword> to search, then perspective-cuts detail <identifier> to inspect parameters. The CLI does the detective work for you.

Q: Can I contribute if I used AI to help write code?

A: Absolutely. The project explicitly welcomes AI-assisted contributions. They practice "partner coding" — humans and AI collaborate, humans review. No gatekeeping based on how keystrokes were generated.

Q: What happens if an action I need isn't in the 180+ built-ins?

A: Use raw identifiers via discover and detail. The built-in library covers common actions; raw identifiers unlock everything else. The language reference documents both approaches.

Q: How does this compare to just writing in Apple's Shortcuts app?

A: Speed, reproducibility, and developer ergonomics. Text files compile in seconds, version cleanly, and don't require visual manipulation. The trade-off is learning a new syntax and accepting experimental status.

Q: Where's the full language documentation?

A: See PERSPECTIVE-LANGUAGE.md in the repository. It includes 12 tutorials, complete action references, AI assistant instructions, and verified test results.

Conclusion: The Future of Shortcuts Is Text

Apple's Shortcuts platform has grown from a simple automation toy into a genuine programming environment — but its visual editor hasn't evolved at the same pace. For developers, power users, and anyone who thinks in code, the friction of drag-and-drop becomes unbearable at scale.

Perspective Cuts is the corrective. It respects Apple's ecosystem (native Swift, official signing, legitimate output) while rejecting the constraints of visual programming. The result is a tool that feels like it should have existed years ago: write shortcuts as code, compile them instantly, deploy them everywhere.

Yes, it's experimental. Yes, things will break. But the foundation is principled, the feature set is ambitious, and the gap it fills is undeniable. In a world where AI actions, Private Cloud Compute, and cross-app orchestration are becoming essential, text-based shortcut development isn't just convenient — it's necessary.

Stop dragging blocks. Start writing shortcuts.

👉 Get started now: github.com/taylorarndt/perspective-cuts

Install via Homebrew, write your first .perspective file, and experience what Apple's automation platform should have been all along. The future of shortcuts is text — and that future is already compiling.