Skip to main content
Security, approvals, and advanced automation Level: Intermediate 12 min read

Execution vs Staging Rules: What AI Operations Require Human Approval

Understand FlightDeck's safety model: learn which operations execute immediately, why mutating actions are staged, and how the Desktop Approval Center keeps you in control.

Published: 2026-11-01 • Last Updated: 2026-11-01 • Author: Kip Lawrence
Key MCP Tools: flightdeck_change_set_stageflightdeck_change_set_statusrelease_readiness_checkapp_store_versions_list

Direct Answer: How FlightDeck Protects Your App Store Data

When you connect an AI coding assistant—such as Cursor, Claude Code, Windsurf, or Antigravity—to Apple's App Store Connect API, you want the speed of autonomous assistance without the risk of accidental mistakes. Giving an AI model unrestricted write access to live production apps could lead to severe errors: accidentally submitting an unready build, publishing incorrect pricing, deleting a beta group, or overwriting localized marketing text.

FlightDeck solves this by acting as an intelligent safety gate between your AI coding assistant and Apple's servers.

FlightDeck enforces a clear boundary between immediate read-only queries and staged mutations requiring human authorization:

  • Read-Only Queries: Fetching metadata, auditing builds, and checking release readiness execute immediately so your assistant can analyze data and answer questions without friction.
  • Mutating Actions: Any operation that modifies, creates, or deletes App Store Connect resources is automatically intercepted and staged as a visual proposal in the FlightDeck Desktop Approval Center on your Mac.

Nothing changes in Apple App Store Connect until you review the proposed diff and click Approve.


What You Need

To experience FlightDeck's approval workflow:

  1. FlightDeck for Mac: Running on your desktop with an active App Store Connect API key.
  2. Connected AI Assistant: Configured via MCP in Cursor, Claude Code, Antigravity, or Windsurf.
  3. Approval Mode Active: FlightDeck's default setting (Approval Required for AI Mutations).

The Three Operational Tiers

FlightDeck classifies every operation your assistant requests into three clear categories:

TEXT
                            ┌───────────────────────────────────────────────┐
                            │        FlightDeck Safety Architecture         │
                            └───────────────────────┬───────────────────────┘
                                                    │
         ┌──────────────────────────────────────────┼──────────────────────────────────────────┐
         ▼                                          ▼                                          ▼
┌─────────────────────────────────┐        ┌─────────────────────────────────┐        ┌─────────────────────────────────┐
│     Tier 1: Read-Only Query     │        │    Tier 2: Local File Checks    │        │    Tier 3: Mutating Action      │
│      (Immediate Execution)      │        │      (Immediate Execution)      │        │   (Staged for Human Approval)   │
├─────────────────────────────────┤        ├─────────────────────────────────┤        ├─────────────────────────────────┤
│ • GET requests to Apple API     │        │ • Offline file inspection       │        │ • Modifies App Store data       │
│ • No changes to remote state    │        │ • Local IPA bundle analysis     │        │ • Creates, updates, or deletes  │
│ • Assistant plans freely        │        │ • Zero network traffic to Apple │        │ • Staged in Approval Center     │
│ • Examples: apps_list,          │        │ • Examples:                     │        │ • Examples: updating text,      │
│   release_readiness_check       │        │   build_upload_preview          │        │   setting prices, submitting    │
└─────────────────────────────────┘        └─────────────────────────────────┘        └─────────────────────────────────┘

Tier 1: Read-Only Queries (Immediate)

When your assistant needs to check which builds are processing, inspect current pricing, or evaluate character counts, it issues read-only queries. These execute immediately. Your assistant gets instant answers, allowing fast diagnostic analysis and natural conversation.

Tier 2: Local File Checks (Immediate)

When preparing binaries or screenshots, FlightDeck inspects files directly on your local workstation without contacting Apple. It verifies file headers, extracts dimensions, checks bundle IDs, and computes SHA-256 hashes offline. Because these checks cannot affect remote App Store records, they execute without delay.

Tier 3: Remote Mutating Actions (Staged for Approval)

Any action that alters your remote App Store presence—such as updating marketing copy, changing territory availability, modifying price tiers, or submitting a release for App Review—is classified as a mutating action.

Under FlightDeck's default security policy, these calls do not touch Apple's API directly. Instead, FlightDeck creates a visual proposal record and waits for your explicit confirmation.


The Seven-Stage Lifecycle of an AI Action in FlightDeck

To guarantee that developers remain in total control while maintaining a fluid conversational experience, FlightDeck orchestrates operations through seven distinct lifecycle stages:

TEXT
┌──────────────────────────────────────┐
│ 1. Read-Only Inquiry                 │  Assistant queries current ASC state (Tier 1: immediate).
└──────────────────┬───────────────────┘
                   │
                   ▼
┌──────────────────────────────────────┐
│ 2. Proposal Drafting                 │  Assistant formulates suggested changes in chat for review.
└──────────────────┬───────────────────┘
                   │
                   ▼
┌──────────────────────────────────────┐
│ 3. FlightDeck Staging                │  Mutating action intercepted and staged locally in FlightDeck.
└──────────────────┬───────────────────┘
                   │
                   ▼
┌──────────────────────────────────────┐
│ 4. Developer Desktop Approval        │  Human inspects semantic diff and clicks Approve in Desktop UI.
└──────────────────┬───────────────────┘
                   │
         ┌─────────┴─────────┐
         ▼                   ▼
    [ Rejected ]        [ Approved ]
  Proposal discarded         │
  Zero remote changes        ▼
                   ┌───────────────────────────────────┐
                   │ 5. Execution Dispatch             │  FlightDeck securely transmits authenticated call to Apple API.
                   └─────────────────┬─────────────────┘
                                     │
                                     ▼
                   ┌───────────────────────────────────┐
                   │ 6. Apple Asynchronous Processing  │  Apple accepts request and updates backend / CDN / review queues.
                   └─────────────────┬─────────────────┘
                                     │
                                     ▼
                   ┌───────────────────────────────────┐
                   │ 7. Assistant Read-Back            │  Assistant queries Apple API to verify committed state in chat.
                   └───────────────────────────────────┘

The Seven Stages Explained:

  1. Read-Only Inquiry: The assistant queries existing App Store Connect resources (Tier 1 call). This executes immediately without creating proposals, enabling fast diagnostic audits.
  2. Proposal Drafting: The assistant designs the proposed change (such as revised marketing copy, new territory availability, or price tier updates) and presents it in chat for your consideration.
  3. FlightDeck Staging: When you ask to apply the change, FlightDeck intercepts the mutating call and registers a staged proposal record locally, preventing any premature network transmission to Apple.
  4. Developer Desktop Approval: You switch to the FlightDeck Desktop application on macOS, inspect the semantic visual diff card in the Approval Center, and explicitly click Approve (or Reject).
  5. Execution Dispatch: Upon your approval, FlightDeck's coordinator dispatches the authenticated mutation to Apple's App Store Connect REST API.
  6. Apple Asynchronous Processing: Apple's backend validates and commits the resource change, dispatching asynchronous background tasks (such as edge CDN cache invalidations or submission pipeline checks).
  7. Assistant Read-Back: The assistant queries Apple's API to confirm that the resource was successfully committed, reporting the confirmed live state in chat.

Three Realistic Prompts: From Inspection to Mutation

1. Read-Only Inspection (Immediate Execution)

Ask your assistant to gather information without making changes:

TEXT
Show me the current pricing and territory availability for [Your App Name] using FlightDeck. Don't change anything.

What Happens:

  • The assistant queries apps_list and app_availability_get.
  • Data is retrieved from Apple's API and formatted in chat within seconds.
  • No approval prompts appear because no remote state is modified.

2. Proposal Without Immediate Execution (Drafting & Review)

Instruct your assistant to draft improvements and show you the proposed changes first:

TEXT
Review the App Store description for [Your App Name] and suggest improvements for conversion and clarity. Show me the proposed copy in chat before staging any changes in FlightDeck.

What Happens:

  • The assistant retrieves your current description.
  • It uses its own language model capabilities to write revised copy.
  • It presents the new draft in chat and explains its reasoning.
  • Remote App Store Connect data remains completely untouched.

3. Approved Mutation (Staged & Authorized)

Once you are satisfied with the draft, instruct your assistant to apply it:

TEXT
The new description looks great. Please stage the update for version [1.2.0] of [Your App Name] in FlightDeck so I can review the proposal. After I approve the change in FlightDeck Desktop, apply it and read back the updated description to verify.

What Happens:

  1. Staging: The assistant sends the request to FlightDeck. FlightDeck halts transmission to Apple and creates a pending proposal.
  2. Review: You switch to FlightDeck Desktop, where a native card shows the exact character diff between the old and new description.
  3. Approval: You click Approve.
  4. Execution: FlightDeck securely transmits the authenticated update to Apple's API.
  5. Verification: Your assistant queries Apple's API to confirm that the new text is saved.

What Happens When an Action is Rejected or Times Out?

Understanding edge cases ensures you always know the state of your application:

When You Click Reject in FlightDeck Desktop

  • The pending proposal is immediately terminated and discarded.
  • Remote App Store Connect data is 100% untouched.
  • FlightDeck informs your AI assistant that the proposal was rejected.
  • The assistant can ask for your feedback and revise its suggestions.

When a Proposal Expires

  • If you step away from your Mac, pending proposals time out safely (typically within 15 minutes).
  • Expired proposals fail closed: no action is sent to Apple.
  • Your assistant can re-stage the proposal when you return.

What Happens If Apple Rejects the API Request

  • Even after you click Approve, Apple's servers might reject an update (for example, if a version draft was locked by an ongoing review or if network connectivity dropped).
  • FlightDeck captures Apple's exact error message and passes it back to your assistant.
  • Your assistant explains the error in plain English and suggests corrective steps.

Non-Atomic Apple API Execution

Developers should understand an essential architectural reality when an AI assistant manages App Store Connect: Apple's REST API commits mutations on a per-resource basis. Apple does not provide a multi-endpoint atomic transaction roll-back mechanism across disparate endpoints.

To protect developers against half-committed multi-resource mutations:

  1. Multi-Mutation Batching: For complex operations (such as localizing release notes across multiple languages), FlightDeck groups requests into an atomic batch proposal using flightdeck_change_set_stage.
  2. Single-Action Staging: Individual mutating operations use flightdeck_operation_stage to intercept calls before they reach Apple.
  3. Authorized Continuation: Once authorized by the developer in FlightDeck Desktop, FlightDeck invokes flightdeck_operation_execute_staged to execute the approved mutation against Apple's endpoints sequentially, verifying each intermediate response.

Staged Proposals vs. Apple-Side Processing

It is important to understand the boundary between FlightDeck Execution and Apple Processing:

  • FlightDeck Execution: Occurs the moment you approve and FlightDeck receives a 200 OK or 201 Created from Apple's REST API. The data is officially committed to your App Store Connect account.
  • Apple-Side Processing: Certain actions trigger background processing on Apple's infrastructure (such as binary ingestion, screenshot CDN propagation, or human App Review evaluation). These processes take additional time and are governed by Apple's systems.

Summary of Operations: Immediate vs. Staged

Operation Type Examples FlightDeck Policy User Action Needed?
Read-Only Inspection List apps, check builds, get versions, audit readiness Immediate None (Executes automatically)
Local File Validation Parse IPA headers, check screenshot dimensions Immediate None (Local only)
Metadata Updates Change description, keywords, subtitle, release notes Staged Approve in Desktop
Pricing & Territories Modify price tiers, enable/disable countries Staged Approve in Desktop
Asset Uploads Upload screenshot sets, attach binaries Staged Approve in Desktop
Submission for Review Create review submission, submit release to Apple Staged Approve in Desktop


Connect Your AI Agent to App Store Connect

FlightDeck runs locally on your Mac, keeping private keys secure in your macOS Keychain and executing mutations only after your explicit approval.

Download FlightDeck on Mac App Store