Although Apple had already incorporated AI-assisted programming capabilities in the initial version of Xcode 26, the experience felt more like ChatGPT being awkwardly embedded into the IDE: the functionality existed, but felt disconnected. Compared to the then-popular Cursor, it seemed like a product from a different era. As AI CLI tools like Claude Code gradually matured, Xcode appeared to fall further behind, leading many developers to question whether it could still serve as a “primary IDE” in the AI age.
The arrival of version 26.3, with almost no advance notice, responded to these doubts with concrete action. By integrating Claude Code/Codex, Apple’s answer was direct: with the right strategy, Xcode remains a highly promising development environment within the Apple ecosystem. This time, Xcode didn’t simply add a CLI tool panel; instead, it introduced a native set of Xcode Tools (MCP), coordinated with official technical documentation for Swift 6, SwiftUI, SwiftData, and more, creating a highly consistent experience aligned with the latest practices. Even for developers already proficient with CLI + XcodeBuildMCP + various Skills, this native solution remains highly competitive—especially with its near-zero configuration cost, which is significant for the vast majority of developers.
More notably, the Xcode Tools provided in this update don’t just serve Xcode itself; they can also function as standard MCP to provide capabilities for other AI tools. This open approach doesn’t entirely align with the outside world’s impression of Apple’s usual style.
Of course, from today’s vantage point, we cannot yet assert that Xcode has returned to the first tier. But what’s certain is that 26.3 has sent a very clear signal: Apple is willing to collaborate with mainstream tools and services to create development experiences that truly align with the times. For this reason, I have higher expectations for the next iteration of Siri—likely in iOS 27, Apple will provide more standardized interfaces for the system and apps beyond the existing Intent framework, allowing AI to integrate more naturally into the entire ecosystem.
Xcode + Agent is just the beginning.
Apple + Agent is the future worth paying more attention to.
Original
Xcode 26.3 + Claude Agent: Model Swapping, MCP, Skills, and Adaptive Configuration
Xcode 26.3 directly provides support for Claude Code/Codex. Finally, developers can conveniently use native AI Agents in Xcode. Over the past few days, I’ve conducted a series of experiments with the new version, including how to use the latest models, configure MCPs/Skills/Commands, and write adaptive CLAUDE.md. This article uses Claude Code as an example to share some tips beyond the documentation.
Recent Recommendations
From Pixel Capture to Metadata: Reimagining Screen Recording Architecture on macOS
Video is replacing text as a more popular form of expression, and good tools accelerate creation. Sintone, developer of the macOS screen recording software ScreenSage Pro, provides an in-depth retrospective on implementing “finished editing upon recording completion” based on ScreenCaptureKit and Metal. From solving the cryptic SCK -3821 error to migrating from ObservableObject to @Observable to optimize timeline performance, this article openly shares the entire process from pixel capture to high-performance composition.
Which Method is Fastest for Checking if a String is in a Whitelist: Set, Array, Enum, Dictionary, or Switch?
In Swift, checking whether a string belongs to a set of keys can be written as Set.contains, Array.contains, RawRepresentable enum’s init?(rawValue:), switch with multiple cases, or even using a Dictionary for mapping. They may look similar, but when placed in performance-sensitive paths, the results might not fully align with intuition. Helge Heß conducted a simple benchmark test: Set.contains leads without suspense, followed by enum(rawValue:) and Dictionary (very close to each other); while switch, which many would instinctively overestimate, actually ranks after enum, with Array.contains finishing last. As a small experiment, these results might be just what we need to calibrate our intuition about Swift performance.
Migrating an iOS app from Paid up Front to Freemium
Paid download and free + in-app purchase are two fundamentally different business models, and as apps evolve, developers may need to transition between them. In this article, Donny Wals shares his complete experience converting the Practical Core Data app from a $4.99 paid download to freemium. The article not only covers StoreKit 2 technical implementation details (purchase flow, state management, family sharing), but more valuably, his deep thinking on business decisions: while the paid barrier can filter for serious users, it also blocks many potential users from experiencing the product’s value. For educational or utility indie apps, freemium may be a better balance between user growth and revenue.
On-demand resources in iOS app
App size has always been a concern for developers, especially when apps contain large amounts of images, audio, or other resources. Although Apple introduced On-Demand Resources (ODR) in iOS early on to address this challenge, this feature has a weak presence and is often overlooked by developers. In this article, Majid Jabrayilov systematically reviews ODR’s working mechanism and usage, including resource grouping, tag management, download lifecycle, and collaboration with system caching strategies.
While Apple is promoting Background Assets as a more modern solution, ODR still has unique value in scenarios requiring immediate response for on-demand downloads and fine-grained resource control.
Objectively Better, Observably Trickier
When fully embracing the Observation framework, developers need to be aware that its working mechanism differs from Combine’s @Published, and simple replacement often introduces subtle issues. Danny Bolella summarizes four common pitfalls during migration: non-lazy initialization when @State holds reference types, update loss caused by nested @Observable objects, changes in array element binding methods, and conflicts with other property wrappers. The article provides solutions through clear code examples and repeatedly emphasizes a core principle: updates only trigger when properties currently being accessed (getter called) by the view change. Understanding and adapting to this “lazy observation” mindset is key to correctly using the Observation framework.
Add an Open Recent Menu to a SwiftUI app
“Open Recent” is a standard macOS app feature, but for SwiftUI developers, correctly implementing this functionality is not intuitive. In this article, Mark Szymczyk demonstrates through a concise example how to use NSDocumentController to integrate system-level recent file management capabilities into your app: automatic list maintenance, menu updates, and seamless coordination with document lifecycle. For document or utility apps, this is a low-cost detail optimization that can significantly enhance the “native feel.”
Tools
Radioform: A Native, Open-Source macOS Audio Equalizer
macOS has long lacked a system-level audio equalizer. Radioform, developed by Matthew Porteous, fills this gap. The project employs a layered architecture of SwiftUI menu bar App + Swift Host + CoreAudio HAL Driver + C++ DSP, completely decoupling UI from real-time audio processing. The DSP portion implements 10-band parametric EQ, parameter smoothing, limiting, and real-time safety control; the engineering also includes complete CI, code signing notarization, and DMG release workflow. This isn’t a “just make it work” demo, but a production-grade audio engineering template approaching long-term maintainability.
CircuitPro: Native macOS PCB Design Tool
This is a domain rarely explored by macOS native apps: PCB design. CircuitPro is a PCB EDA tool for macOS, aiming to make schematic, layout, and component library workflows more aligned with Apple platform conventions. (The project is still in early development stages)
What attracts me most about the project is the custom-built CanvasKit. It’s more like a 2D interaction engine for EDA scenarios rather than just a regular canvas component: the top layer is declarative CanvasView, the middle layer is the state hub CanvasController, and the bottom layer is input routing, render tree, and tool system. More critically, snapping, input handling, and wiring engine are all made into protocol-based pluggable points, allowing schematics and layout to share the same infrastructure while retaining their respective routing rules.
Even if you’re not interested in PCB design itself, CircuitPro is worth attention, especially for its engineering practices in SwiftUI + AppKit hybrid architecture.