Alex Sidebar Alternative: Why Phoenix.vu Is the Best AI Coding Agent for Xcode (2026)

August 07, 2026

Phoenix.vu AI coding agent running beside Xcode as the best Alex Sidebar alternative for Swift and Apple developers

Alex Sidebar proved the model Apple developers actually wanted: a native macOS app that sits beside Xcode instead of replacing it. Then, in September 2025, OpenAI acqui-hired its three-person team into the Codex division, and Alex stopped taking new downloads. Phoenix.vu picks up the same architecture and keeps building — with the Apple compliance tooling and documented security model Alex never got to ship.

01 The actual problem

A great idea, paused mid-flight

Alex Sidebar got the shape right early: a native macOS companion that hooks into the frontmost Xcode window, downloaded by more than 25,000 developers, it became the reference point other tools got compared to — "the Cursor for Xcode," as more than one reviewer put it.

Then, in September 2025, OpenAI hired Alex's three-person team into its Codex division. The company halted new downloads on October 1, 2025. Existing users keep the app and continue to get support — but no new features are shipping, and the roadmap that would have added what it was missing — build integration, App Store compliance checks, a documented security model — stopped there.

Phoenix.vu starts from the same architectural bet — a companion, not a replacement — and keeps going from where Alex left off.

02 Architecture

Same shape, different reach

Neither tool asks you to leave Xcode's editor. Alex triggers off keyboard shortcuts inside the frontmost Xcode window; Phoenix.vu opens as a fixed-width, non-activating panel docked beside it. The difference isn't "companion vs. replacement" here — both got that right. It's what each companion is allowed to see and touch once it's there: Alex's own docs ask for broad folder access (Desktop, Documents, Downloads) to analyze files; Phoenix.vu confines every read and write to the project root, with symlinks resolved before the check.

03 Build & code understanding

Reactive fixes vs. an owned build

Alex's error resolution reacts to what Xcode's own compiler already surfaced — click, and it proposes a fix for the error Xcode is already showing. Phoenix.vu's run_build tool goes a step further: it calls xcodebuild directly, resolves the scheme itself, and parses the resulting .xcresult bundle into structured diagnostics — so the agent can trigger and read a build on its own, not just respond to one you already ran.

Code search follows a similar gap. Alex indexes the project with VoyageAI embeddings stored locally for semantic search. Phoenix.vu instead parses the codebase with SwiftSyntax and cross-references it with SourceKit's own semantic analysis — a real dependency graph, not similarity search over vectors.

04 Specialised tools built on Apple's actual rulebooks

Alex's feature list — quick actions, inline edits, search, image-to-code — covers what a coding assistant does for any project. None of it is Apple-specific compliance work; that was never on its shipped roadmap. Phoenix.vu ships four tools built directly on Apple's own rulebooks:

Privacy Manifest Generator — PrivacyInfo.xcprivacy

Every value is a closed enum from Apple's own catalog — the model can't invent one Apple doesn't define.

scan evidence → judge (cited) → validate → write

Memory Diagnostics — retain-cycle detection

Parses source into a real Swift ownership graph, states whether each object reaches deinit. Disputed findings move to a visible "ruled out" list, never silently dropped.

ownership graph → detect → explain + fix

App Review Checker — guideline-cited findings

Reads the merged Info.plist (including INFOPLIST_KEY_* build settings), entitlements, and asset catalog. Cites the exact guideline number and names who can fix it.

build inputs → rules → judge + assign owner

HIG Analyzer — interface guideline audit

Resolves whole SwiftUI control regions, not single lines. Cites the HIG chapter and runs on your own configured model.

resolve controls → checks → judge on your model

It's a local, deterministic scan first; the model only judges evidence it's shown, and citations are checked against what the scanner found. A finding that's already certain never reaches the model at all.

05 Security posture

A promise vs. a mechanism

Alex's privacy stance is genuinely good: code embeddings stored locally via VoyageAI, no code collection, an opt-out from third-party training. That's a promise about what the company won't do with your data. Phoenix.vu publishes the mechanism instead — a documented, layered threat model you can read and audit:

Only you (your typed messages) and the app's own system rules can direct the agent. Everything else — file contents, tool output, images, documents, build logs, prior turns — is treated as untrusted data, never as instructions.
— Phoenix.vu security model
  • Commands are classified, not trusted. Hard-block / approval / auto-allow. Privilege escalation and force-push never run; everything else needs your yes, with a reason shown.
  • Chaining can't hide a second command. Pipes, &&, subshells, even embedded newlines force full approval.
  • Secrets never reach a model. .env, private keys, and GoogleService-Info.plist are withheld entirely; anything token-like is masked before it leaves the machine.
  • File access stays inside the project. Reads and writes are confined to the project root; Alex's own docs ask for Desktop, Documents, and Downloads access up front.
  • Every mutation is a snapshot. Writes are reversible; deletions and build-file changes need approval; a runaway-edit breaker pauses large unsupervised changes.

Phoenix.vu runs outside Apple's App Sandbox, since reading arbitrary Xcode projects and spawning xcodebuild can't work inside one — a documented trade-off, compensated by the controls above.

06 Models & cost

Pay only for what you use

Alex runs two fixed tiers: Pro at $30/month for 600 chat credits, and Unlimited at $200/month, single-device only. Run out of credits mid-month and you're buying top-ups at $12.50 per 250, none of which roll over from the base plan.

Phoenix.vu uses a straightforward prepaid credit system instead. Add credits whenever you need them and spend them only when you run AI tasks — no monthly cap, no subscription tier to outgrow. You still choose the model behind it: Claude, DeepSeek, Kimi, or any OpenAI-compatible endpoint.


Head-to-head: feature by feature

Project status
CapabilityPhoenix.vuAlex Sidebar
Development statusActiveFrozen — team joined OpenAI's Codex division, Sept 2025
New downloads / signupsOpenClosed — halted October 1, 2025
New featuresShippingNone planned — existing users still supported
Relationship to Xcode
CapabilityPhoenix.vuAlex Sidebar
Editor roleCompanion — Xcode stays the editor of recordCompanion — same approach
Build executionDirect — xcodebuild via a dedicated runnerReactive — fixes errors Xcode already surfaced
Build result understandingStructured — parses .xcresult, citedNot documented
Codebase searchDependency graph — SwiftSyntax + SourceKitVector search — local embeddings (VoyageAI)
File/folder accessConfined to project rootBroad — Desktop, Documents, Downloads
Apple-specific tooling
CapabilityPhoenix.vuAlex Sidebar
Privacy Manifest generatorYes — closed vocabulary, citedNo
Retain-cycle / memory diagnosticsYes — real ownership graphNo
App Store Review Guideline checkerYes — cites guideline numberNo
Human Interface Guidelines auditYes — cites HIG chapterNo
Agent & models
CapabilityPhoenix.vuAlex Sidebar
Where the agent runsLocalLocal
Model choiceClaude, DeepSeek, Kimi, OpenAI-compatibleOpenAI, Claude, Fireworks, Cerebras, Gemini, local (Ollama)
Terminal command safetyClassified + gated, anti-chainingDirect execution, no documented gate
Secret redaction before egressYesNot documented
Pricing modelPay-as-you-go credit top-up modelFixed tiers — $30–$200/mo, credit-capped
Everyday extras
CapabilityPhoenix.vuAlex Sidebar
Voice dictationYesYes
Image/design-to-codeYes — vision sidecar builds/fixes UI from a screenshotYes — drag-and-drop
Inline diff explanationsYesNot documented
Inline tab-completionNone — by designYes — unlimited on paid plans
Build performance analysisYesNo
Local/offline model supportNoYes — via Ollama

Alex Sidebar figures reflect its public docs, pricing page, and reporting on the OpenAI acquisition as of the app's last shipped state (sources below).


07 Where Alex Sidebar still wins

Choose Alex Sidebar when:

  • You want inline tab-completion as you type, already tuned and shipping.
  • You want a fully local, offline model via Ollama for maximum privacy.
  • You're already using it and it still does the job you bought it for.
  • You need the broader off-the-shelf model roster (Fireworks, Cerebras, Gemini) without configuring your own.

Choose Phoenix.vu when:

  • You want a tool with people actively building it.
  • You need App Store compliance, memory safety, and HIG checks grounded in Apple's rules.
  • You want documented, auditable command-execution safety and project-scoped file access.
  • You want usage-based pricing instead of a monthly credit cap.

08 Verdict

Alex Sidebar got the shape right. Phoenix.vu kept building it.

Alex Sidebar proved that a native companion beside Xcode — not a replacement for it — is the right shape for Apple developer tooling, and its privacy stance was genuinely ahead of the field. But the three people who built it now work on OpenAI's Codex team, and the app hasn't shipped a new feature since October 2025. Phoenix.vu starts from the same architecture and keeps going: the same non-intrusive companion, plus the App Store compliance tooling, the documented security model, and the direct build integration Alex never got to add. For a Swift developer choosing a daily driver in 2026, the question isn't which sidebar looked better first — it's which one still has someone behind it.

09 FAQ

Does Phoenix.vu support App Store compliance?

Yes. Phoenix.vu includes dedicated tools for:

  • Privacy Manifest generation
  • App Review Guideline checks
  • Human Interface Guidelines analysis

These tools reference Apple's published documentation during analysis.

Which AI models does Phoenix.vu support?

Phoenix.vu supports multiple AI providers, including Claude, DeepSeek, Kimi, and OpenAI-compatible endpoints, allowing developers to choose the model that best fits their workflow.

Is Phoenix.vu subscription-based?

No. Phoenix.vu uses a prepaid, pay-as-you-go credit system rather than fixed monthly subscription tiers.

How is Phoenix.vu different from Alex Sidebar?

While both applications work alongside Xcode, Phoenix.vu adds features such as:

  • Direct build execution using xcodebuild
  • Privacy Manifest generation
  • App Store Review Guideline checking
  • Human Interface Guidelines (HIG) auditing
  • Memory diagnostics
  • Project-scoped file access
  • Documented security model

These capabilities are designed specifically for Apple application development.

AI-Powered Xcode Development

Stop Copy-Pasting BetweenXcode and AI

Phoenix.vu is the AI for Xcode, built directly into your workflow.