Coding with Intelligence

With Xcode 26 and macOS Tahoe, Apple introduced something pretty remarkable: built-in AI coding assistance. You can now use models like ChatGPT and Claude directly inside Xcode, no extra setup required.

For more details on how this works, check out Apple’s official documentation.

In this post, I’ll share what’s worked best for me, what was terrible, and include a quick example of how you could use this new feature in your daily workflow.

Built-In Model Support

In the new Intelligence settings, you can select from supported AI models. ChatGPT and Claude are built-in, and you can also choose your own Model Provider, if you prefer.

Keeping It Simple

In my experience, Xcode’s AI assistant works best with simple, localized tasks.

If I ask it to:

• Implement a single function based on a short description
• Refactor a small logic block
• Write helper extensions or convenience methods
• Write unit tests

…it’s excellent.

Where it struggles is when the change touches several files, types, or layers of the app. Keeping prompts focused and contained gives the best results.

A Quick Real-World Example

For fun, I created a new Project in Xcode and fed the AI model the following prompt:

1
2
3
4

I want to convert farenheit to celsius. Allow a user to enter a
temperature in farenheit and when they tap a "convert" button it
displays the result. Include unit tests using the swift testing
framework.

Xcode includes Coding Assistant pane that is conversational. You type something, and it responds. Its response to my prompt was detailed, and helps to make sure it’s on the right track to writing code.

It summarizes my ask:

1
2
3
4
5
6
7
8
9

You're asking to add a simple Fahrenheit-to-Celsius converter UI
and include Swift Testing unit tests.

Changes I'll make
- Update ContentView.swift to include a `TextField` for
  Fahrenheit input, a "Convert" button, and a result display.
- Add a small conversion helper to keep logic testable.
- Create a Swift Testing test file that verifies the conversion
  logic and some basic UI-driven behavior.

The result, while it won’t win any design awards, is actually not bad for very little human development effort! Here’s a look at the UI generated:

And let’s take a look at the function it created to perform the temperature conversion calculation:

1
2
3
4
5
6
7

struct TemperatureConverter {
  /// Converts a temperature in Fahrenheit to Celsius.
  /// Uses the formula: (F - 32) * 5/9
  static func fahrenheitToCelsius(_ f: Double) -> Double {
    (f - 32.0) * 5.0 / 9.0
  }
}

This is the kind of small, self-contained task where coding intelligence really shines. The inline documentation is a nice touch, however, I would like to have seen it use - Parameter: and - Returns: for complete documentation. While we’re here, I might as well ask:

1

Add appropriate swiftdoc to fahrenheitToCelsius

Here’s that verbose text that AI is good for:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

/// Converts a temperature from Fahrenheit to Celsius.
///
/// This method applies the standard conversion formula `(F − 32) × 5/9`.
///
/// - Parameter f: The temperature in degrees Fahrenheit.
/// - Returns: The converted temperature in degrees Celsius.
///
/// - Note: The calculation is performed using `Double` precision.
///
/// - Example:
/// ```swift
/// let celsius = TemperatureConverter.fahrenheitToCelsius(68)
/// // celsius == 20.0
/// ```
static func fahrenheitToCelsius(_ f: Double) -> Double {
  (f - 32.0) * 5.0 / 9.0
}

For developers, now quick help is available with all the info:

Of course, all good code should come with some accompanied tests!

1
2
3
4
5
6
7
8
9

@Suite("TemperatureConverter Tests")
struct TemperatureConverterTests {
  @Test("32°F is 0°C")
  func freezingPoint() async throws {
    let result = TemperatureConverter.fahrenheitToCelsius(32)
    #expect(result == 0, "32°F should convert to 0°C")
  }
  ...
}

It generated six other @Tests as well, testing different values and bounds of temperatures, but I’ll omit those tests here for brevity.

As a side note, Xcode had some trouble creating my new test file…restarting Xcode seemed to help. Once the file was created and added to the project, it was added to my app target (and not the test target). After fixing this issue, the tests were useful and did a good job of testing my conversion function with a few example values.

Final Thoughts

This new wave of coding intelligence in Xcode 26 feels like the right balance between power and restraint. It’s not trying to replace developers, it’s helping us move faster and learn along the way.

It’s far from being perfect, but it can be a useful tool to help increase productivity and perform mundane tasks like code documentation and writing unit tests.

If you approach it with that mindset — letting it handle focused, well-defined tasks — it can be a genuinely useful companion in your day-to-day workflow.

Have you tried coding with intelligence in Xcode 26 yet?

Photo by Zan Lazarevic on Unsplash