J.

XCODE 26.3: AGENTIC FEATURES - MY NEW WORKFLOW

My experience using Xcode 26.3 with the new agentic coding features, expanded AI integration, and what works (and what doesn't) for daily iOS work.

Xcode 26.3 with agentic coding features

I have been using Xcode 26.3 for a couple of weeks now and I want to write down my impressions while they are still fresh. Apple finally pushed the AI story further than autocomplete, and the new agentic features change quite a lot how I work day to day. Some of it is genuinely useful, some of it still feels like a beta inside a beta. 🤔

This is not a release notes copy-paste. I will go through the features I actually used on real iOS projects, what I liked, and where I had to disable things and go back to the old way.

What’s new in 26.3

The headline change is the move from “Predictive Code Completion” to a proper agentic mode inside the editor. You can now hand a task to Xcode, give it some context, and let it edit multiple files, run the build, read the errors and try again. It is not a chat panel bolted on the side anymore, it sits inside your project. ✨

Other things that landed in this release:

  • A new Coding Agent panel with task history per project
  • Inline diff previews before agent edits are applied
  • Better integration with Apple Intelligence for on-device suggestions
  • Build log summarization (very useful when SwiftUI previews fail with a wall of red)
  • Improved test generation, now aware of your existing test targets
  • Tighter Swift 6 concurrency hints, surfaced as fix-its by the agent

The agent can run on-device for small tasks and fall back to a server model for bigger ones. You can pick the behavior per project or globally.

My setup for the last weeks

For context, I have been using Xcode 26.3 on two projects: a medium-sized SwiftUI app with around 80k lines of Swift, and a smaller React Native iOS module that I maintain. Both have CI, tests, and the usual mix of UIKit / SwiftUI / Combine / async-await code that you find in real apps.

I enabled the agent in both, but with different settings:

  • SwiftUI app: agent on, on-device for completions, server model for multi-file tasks.
  • RN module: agent on for the native side only, off for the JS bridge code (it kept guessing wrong on the TypeScript types).

The good parts

Agentic refactors actually work

This is the feature that surprised me the most. I gave it tasks like “extract this view into its own file and update all the call sites”, or “convert this @ObservedObject to @Observable”, and it did the full thing. Multi-file edits, imports, even the small touches like updating the previews. 😄

The flow is:

  1. Select code or describe the task in the agent panel
  2. Agent proposes a plan (which files it will touch)
  3. You approve or edit the plan
  4. Agent does the edits, builds, fixes errors, builds again
  5. You review the diff inline before applying

The “review the diff inline before applying” step is what makes it usable. Without that I would never trust it on a real codebase.

Build log summarization

If you write SwiftUI you know the pain of a 200-line error message that ends with “Failed to produce diagnostic for expression”. The new build log summarization condenses these into something readable, often pointing at the actual line where the type inference broke.

For me this alone justifies the upgrade. I lost too many hours of my life to those errors.

Test generation that respects your test targets

Previous versions would generate tests in a random place or assume XCTest when you were using Swift Testing. Now the agent reads your test target setup and writes tests in the right framework, with the right imports.

Example: I asked it to generate tests for a UserSession actor in a project using Swift Testing, and it produced:

import Testing
@testable import MyApp

@Suite("UserSession")
struct UserSessionTests {
    @Test("starts in signed-out state")
    func initialState() async {
        let session = UserSession()
        #expect(await session.isSignedIn == false)
    }
}

Not perfect, but a solid starting point. I usually adjust naming and add a couple of edge cases, but the boilerplate is gone.

On-device completions feel fast

For simple completions inside a function, on-device is genuinely faster than the previous server-based predictive completion. Latency is much lower, and it works offline (planes, trains, cafes with bad wifi). The suggestions are not as smart as the server model for bigger context, but for the 80% case of “finish this line”, it is great. 🚀

Where it falls short

Cross-module context is still limited

If your project has many SPM modules, the agent sometimes loses track of types defined in another package. I had a few cases where it suggested code referencing a type that did not exist, or a property name that was renamed in the actual module.

My workaround is to keep the agent scoped to one module per task. Trying to do “rename this protocol everywhere in the workspace” still works better with the classic Xcode refactor tool.

Test generation for UI tests is rough

Unit tests are good. UI tests with XCUIApplication are still hit or miss. The agent tends to generate brittle queries based on labels that may change, and it does not handle accessibility identifiers as well as I would like.

It’s slow on Intel Macs

Not a surprise, but worth saying. If you are still on an Intel Mac, the on-device agent is painful. Apple Silicon is where this release shines.

Privacy settings are confusing

There are multiple toggles for what gets sent to Apple’s servers vs what stays on-device, and they live in different panels (Xcode Settings, project settings, and a system-level one in System Settings). I had to read the docs twice to understand what was actually happening with my code.

How my workflow changed

Before 26.3, my loop was:

  1. Write code, hit a wall
  2. Switch to a chat tab (Claude, ChatGPT)
  3. Paste context, ask, paste back
  4. Repeat

Now a lot of that lives inside Xcode. I still use external agents (Conductor, Claude Code) for bigger multi-file tasks or for writing prose, but for “finish this function”, “refactor this view”, “explain this build error”, I rarely leave the editor anymore.

My rough split today:

  • Xcode agent: small refactors, completions, build error help, test scaffolding
  • External agents (Claude Code, Codex via Conductor): bigger features, cross-repo work, writing
  • Manual coding: the parts that need actual thinking, which is still a lot 😅

If you are curious about the multi-agent side, I wrote about that in my Conductor post.

Should you upgrade?

If you ship iOS apps for a living, yes. The agentic features are not perfect but they are useful enough that going back to 26.2 felt slow. Just be ready for:

  • Some random hangs in the agent panel (a restart fixes them)
  • Higher RAM usage, especially with the server model
  • A learning curve for the new privacy settings

If you are on an Intel Mac or you do not use AI tools at all, the upgrade is less exciting. The non-AI changes are minor.

Final thoughts

Xcode 26.3 is the first release where I feel Apple is taking the AI story seriously inside the IDE. Until now, the best AI tooling for iOS lived outside Xcode (Cursor, Claude Code, third-party plugins). With this release, a lot of that comes home. 💡

It is not going to replace external agents for me, but the line between “Xcode” and “AI assistant” is much thinner now, and I think that is the right direction. Next stop: an agent that can fix my SwiftUI previews before I even notice they broke. One can dream.