Xcode, agents, and you

Hello! I'm Devin! And I'm Maxwell! We are both members of the Xcode Intelligence team. And we're excited to show you how using agents in Xcode can enhance your development. In Xcode 26.3 we introduced coding agents along with tools to help you tackle complex, multi-step tasks.

In Xcode 27, you can be even more productive. We've expanded the tools Xcode provides and redesigned how you interact with agents. All with the goal of keeping you focused on the work that you enjoy. You drive the vision for your code, and Xcode helps you get there faster and with confidence.

Xcode adapts to you, whether you are just getting started with agents or consider them an essential part of your workflow.

Together with Devin, I'll walk you through using agents in Xcode throughout your development. I'll start by exploring a project to gain an understanding of its structure.

I'll use that understanding to plan and build out a new feature.

Then, Devin will refine what I've built. And finally, he'll orchestrate multiple conversations to accomplish specific tasks. Let's get started! When Maxwell and I are not at the office working on apps, we're spending time at the gym. We've wanted something that helps us track exercises in our workouts. We want something that is personalized and adaptive to how we train. So, together we're building an app that has exactly the features we want. I just got this app off the ground using an agent in Xcode, and it already has the basic functionality we need. It has a workout page to track exercises. And a history section to show previous sessions.

This app is really great. One thing that I would like is if I could see how I'm progressing over time, now that I'm tracking all these workouts. I was thinking the same thing! We need an insights view. That sounds like a great idea. I'll start by creating a prototype to show analytics using previous session data. Perfect! I can refine it from there once everything is in place.

Devin has the project in a great starting place, and I want to familiarize myself with everything he's done already. So I'll start by using Xcode as a guide to both explore the project and learn what options I have for adding insights data. When you use agents in Xcode to explore, they can see your whole project. From your source code, build settings, and even open files and active selections, agents are tuned into exactly what you're working on in the moment.

To start exploring, I'll hold Option and Shift while clicking on the button in the toolbar to create a new conversation. This opens a conversation as a separate editor pane so I can also see individual files and look into specific ones as I explore. I'll ask the agent to summarize the project's data models and current view hierarchy, and provide a walkthrough. I'll send this prompt, and the agent uses Xcode's tools to gather context, and piece together the project's structure.

When jumping into a new project, it can be challenging to determine where you should start. When reading complex architecture and a collection of source files, piecing together how everything connects to build an understanding can take considerable time.

Xcode can help you here. You can ask for a walkthrough to distill down the architecture into something easier to understand, complete with rich details like outlines of data flow, tables of key areas and source code references. When you want to investigate at a deeper level you can navigate directly to key files.

The walkthrough is complete, and I can read through it to build an understanding at a high level. And if I want to look deeper into our workout views, I can click on the links and jump directly into the individual files. This walkthrough is a great reference. But I don't want to lose all this detail in one conversation, I'd like to preserve it. That way I, or anyone else on my team, can reference it later and get up to speed faster.

I've read all the source files that I need to for now, so I'll close the other editor pane and focus in on just the conversation. I'll ask Xcode to draft up two architecture documents with the information gathered, and place them directly in the project with the source code.

In this conversation, the agent started from scratch. It needed to search, read, and investigate all the code in the project to reach an understanding. This discovery loop takes time away from getting started on the work you enjoy.

But instead of losing that effort, it can be captured into a documented knowledge base in your project. This knowledge base can be dynamic and evolve right alongside the codebase. Now, when you or your team start on a new feature, you have a map to quickly find the relevant files and get started.

All the information from the walkthrough has been collected into two documents that I can see as new artifacts alongside the transcript.

When working with agents in Xcode, there are two distinct areas of information that you'll see. On the left, there is the transcript, this is where you see your conversation, including commentary on progress, tool calls, running sub-agents, and more.

On the right, we have artifacts. These are things that are created: files, edits, and previews. You can focus on everything produced in the latest message, or look at the entire conversation as a whole.

After this exploration, I have a good understanding of the project in its current state. So now I can start working to add insights, with some tables to visualize them. I'm not completely familiar with how to implement tables in SwiftUI and the nuanced details of SwiftData models that will need to be adjusted. So, I'll use Xcode to research these APIs and gain an understanding. I'll create a new conversation for this. so I'll open the coding assistant in the sidebar, click new conversation, and choose an agent. I'll ask about the areas I'm unfamiliar with, like what relationships I'll need for the SwiftData Models, and what options I have for creating tables in SwiftUI. I'll also reference the two documents I created earlier.

I'll send this prompt, and the two documents are read right away to gain context on the project. Since I asked about options for adding tables, Apple Document Search is invoked automatically to gain more understanding of SwiftUI table support.

When adopting APIs or entirely new frameworks, having the most current information is important to get the best result. However, depending on the agent you're using, its base knowledge might not include the latest framework information. With Apple Document Search, your agent can access high quality documentation to help you ensure your project is adopting the right solution for the feature you're building. I now have a nice walkthrough of the APIs I'll want to use, complete with key details to consider that I might not have realized otherwise. Details like ensuring my SwiftData model relationships are right, and the best presentation of data on smaller screen sizes. With this, I have a good understanding of both the project and the APIs that I'll need to build out my feature.

Exploring with agents in Xcode is a fast way to familiarize yourself with a new project, or an unfamiliar feature of an existing one. Agents can see your entire project context, can supplement that context with high quality documentation from Apple, and can provide guided explanations for new areas, so you can get started faster than ever.

Now that I have a good understanding of the project, I can start building towards my goal of adding insights.

In the same conversation, I'll put Xcode in plan mode by using the slash command. Plan mode allows you to be the architect, outlining your approach before any code gets written.

I'll specify that I want to add a new tab for workout insights. I'll provide a high level overview of the features I want, outlining any requirements to make sure that this stays focused.

I'll specify the device specific details learned from the explore phase for presentation.

And finally, I'll ask for a preview to ensure the new tab looks like I expect.

I'll send the prompt and enter plan mode. Xcode works with the agent to start planning how to implement the insights tab.

When you build with agents in Xcode, you can turn ideas into features so quickly. Because of this, your workflow naturally shifts, ensuring you have the right plan, that captures your ideas and the architecture you want to build, becomes a more important step.

When you focus on planning, you ensure that later on, refinement is spent polishing up the feature that you want rather than fixing a poorly built foundation.

Xcode gives you the tools to make this happen. It turns planning into a discussion, aligning on strategy before moving to implementation. Speaking of discussion, I have a general idea for what metrics I want to show. But I want to make sure I agree with what's included in the plan.

I'll send a follow up, asking for some ideas. This queues up the message so that once the agent is finished with its current work it can address my question. Queuing messages like this allows me to express my ideas in the moment rather than waiting for the agent to finish what it's currently doing.

Xcode has submitted my message to the agent, and it's come back with some options to choose from. Looking at what it provids, I think that a per exercise view and a top level summary will be good presentations to start out with, so I'll choose those options and send my response.

When you use queued messages to provide additional requirements, and the agent is able to ask questions for clarity, you create a tight communication loop between you and the agent. And because you're involved in the discussion throughout the process, you end up with a much stronger, well thought out plan.

Looks like the plan is finished! We can see the full plan in markdown, which allows me to review it and make any edits that I need directly. This looks pretty thorough to me though, and captures everything discussed earlier. So I'll approve and Xcode starts working with the agent to implement the plan.

The first change has already been made, and we can see the exact diff of the modification as an artifact.

Source code modifications and new files appear as artifacts as they're made and are added to your project. Allowing you to stay in sync and review the code changes to make sure they are what you expect.

Looks like all the source changes have been made, and the agent has moved onto validation. Xcode's build tool is being used to ensure that the changes are correct and it looks like there are initially some issues. But since build errors are communicated directly to the agent, it knows exactly what failed, can quickly iterate, and build again to make sure it's right.

The agent is also updating our architecture documents with the new code, making sure this knowledge base stays up to date.

Now, it's moved onto previews, after resolving some issues with the SwiftData changes, it renders a preview on the current run destination. Previews are also artifacts, so we can click on the rendered preview and take a look. It looks great, and is exactly what I was looking for on iPhone, a concise view with a top level summary. Xcode provides agents with the same tools that you have to ensure that new code does exactly what it's supposed to. From building the project, to rendering a preview of a new UI, you can have confidence that the code is correct.

Let's take a look on iPad so we can see the new tables as well. I'll run this on an iPad simulator so I can see it on device hub. We have the new insights view with a collection of data about our recent training and most recent exercises. And we can see even more detail with the exercise breakdown table. Now that I'm happy with the UI that we see in the simulator, I want to make sure all the changes are built on a solid foundation. I'll ask Xcode to write some unit tests for the changes made to the swift data models.

I can see my existing test suite is picked up for the project, so these tests will be grounded alongside the other testing that we already have.

In addition to build and preview, agents can use Xcode's test tools to ensure that the new code is correct by writing new tests or running existing ones. When agents are provided these opportunities to validate work as they go, you can focus on the high level goals for the feature.

The agent wrote a whole suite of tests to validate the new changes, and it was able to run and verify all twelve new test cases passed. Now we can know with confidence that the insights view is reliable.

Building in Xcode lets you focus on the vision for a feature. You can align on ideas with plan mode, steer discussion in real time, view artifacts as they're produced, and use Xcode's validation tools to ensure new code is correct. Throughout every part of the development process, Xcode is with you to build it right. This is a great start. With Xcode I've been able to get the insights view prototyped in no time. Now, that we have this analytics data, I think the app needs a fresh perspective, from someone with an eye for detail. Hey Devin, the insights view is off to a great start, and already has some great analytics for previous workouts. I do think though that this app could really use some visualizations to show progress over time. Do you want to take over from here? Absolutely! I think Swift Charts would be perfect for that. Maxwell has left this project in a great state. We have a good starting place for adding some visualizations, so let's jump right in! in! So far, we've shown you how you can use agents to explore a new codebase, plan out features, and build them with ease. Now, we need to take the next step: getting things to look and feel exactly how we want. I really like what Maxwell has done on our analytics screen. To bring it to life, we're going to add some charts using Swift Charts.

Now, how a chart looks, how animations feel, and what colors work with your app's style, these are subjective preferences that often change as you work. You can iterate on visual design incredibly fast, which is why staying in the loop for every change matters… making sure the end result reflects your vision.

You can communicate your intent with more than just text using images, sketches, and documents to show exactly what you have in mind. And when you know exactly where an adjustment belongs, you can point directly to that spot in your code with inline annotations resulting in focused, targeted changes. Let me show you what this looks like.

I'm rather new to Swift Charts, so I'll start by exploring what chart styles would work for our data. Here's the prompt. I'm asking what options would work best for the Insights view.

These are all great options, but I want to see them in context. Let's generate previews for each chart type using artificial workout data.

With Xcode, we go from text descriptions to working prototypes in seconds, so instead of just imagining what a chart might might look like we just look at it. Now I can see what these charts actually look like with realistic data. The "volume over time" option is the clear winner. It shows our progress in the weight room at a glance, which is exactly what we want.

The previews look great, but there are still a few things I'd like to personalize. Let me grab my iPad to sketch out a museum worthy chart design. I have Freeform open on my iPad let me sketch out what I'm picturing.

Wow, that really is museum worthy. Yeah, it's really coming together.

Ok, maybe I shouldn't quit my day job but thankfully, I think this gets the idea across! Now I'll send my sketch and ask for a line chart to be added directly to the InsightsView, matching the style I've drawn. While that's being implemented, let me explain what's happening behind the scenes. With access to previews in Xcode, agents don't just generate code and stop. Previews can be rendered incrementally to visually verify results, confirming that what was generated matches what you asked for. If something doesn't look right, adjustments are made before you even need to step in.

And here's what that looks like in practice. My sketch was interpreted and translated into a chart that matches exactly what I was looking for. You can see that a preview was rendered along the way that self-verification loop in action.

This is looking great! There are still a couple of things I'd like to tweak though. I want to add a subtle animation to the chart, and change the color scheme to match our app's theme. I know exactly where these changes should go, and with inline annotations, I can point to that exact spot in my code.

I'll leave two annotations right in the chart view. One here, asking to add a fade-in animation.

And another here, asking to adjust the trend line color to match our theme Inline annotations carry something that a typical conversation prompt doesn't, the exact location in your code where you want to make a change.

When you annotate a specific line, the surrounding code becomes part of the context. The annotation doesn't just say what to change, it shows where, so the result is precise and scoped to exactly what you intended.

This looks incredible.

Every step of that process kept us in the driver's seat. We chose the chart type. We sketched the design. We pointed to exactly where the final adjustments belonged. The creative direction was ours the entire time. In Xcode, you have the tools to make refinement even better: Rich previews to see changes with realistic data; Inline annotations to direct your changes right from your source code; and image Attachments to show exactly what you have in mind. For more on design-focused techniques for working with agents, check out "Create UI Prototypes using Agents in XCode" session. Next, I'll show you how to orchestrate comprehensive feature development by translating our app into new languages, and making it accessible.

For Maxwell and me, it's really important that the apps we develop are accessible. A friend of ours at the gym primarily speaks Filipino, and we'd love for him to be able to use this app just as easily as we can. Accessibility and localization are how you make sure your app works for everyone. And with agents, incorporating these features into your app is easier than ever. Xcode provides a rich set of tools that extend what you can accomplish. Maxwell and I have already shown you tools like Document Search, Preview Rendering, and Run All Tests in action but there are many more. Some are built into Xcode, some are provided by Apple framework teams, and you can even add your own. The right tools are discovered and used automatically based on the task at hand. I'll start a new conversation for localization, asking to translate every user-facing string into Filipino and configure the strings catalog. I'll send this off. You can see the machine translation tools being discovered. These provide the context needed to translate our app, and the work can now begin.

This is orchestration in action. I described a high-level goal: "localize the app into Filipino" and the right tools were discovered automatically. From here, the work gets broken into parallel pieces, and smaller sub-agents are deployed to located and translate strings across the app.

While localization runs, I'll start a second conversation for accessibility, asking to add VoiceOver labels and accessibility identifiers to all interactive elements.

There are now multiple workflows running at once. Accessibility is implementing changes across our views, and localization is coordinating translation through sub-agents. What's interesting about localization is that the translation tools aren't being called by us directly they're invoked by the sub-agents under the hood. The main conversation read those tools for context, broke the work into pieces, and each subagent is now calling on specific translation capabilities as it works through its portion of the app.

This is the power of orchestration: you describe the goal, and the right tools are used at the right level some by the main workflow for planning, others by sub-agents for execution. And through all of this, you can check in on progress at any time. Now it's time for the most important part, reviewing the results. The app is localized in Filipino. Our 'Start Workout' button, the 'History' tab, the 'Insights' section, all translated. And the strings catalog has entries for every user-facing string in the app. Let's enable VoiceOver.

"VoiceOver On" "Start New Workout button" "Landscape" "Charge port to the right" "Start New Workout" "Workouts" "Back button" "Workouts" "Heading" "VoiceOver Off" Every primary element is labeled and navigable. What would have previously been hours of repetitive work was accomplished across two parallel conversations. And we stayed in control the entire time.

Working with agents in Xcode puts you in the driver's seat. Orchestration is where you get to describe high-level goals, and Xcode determines how to accomplish them discovering the right tools, coordinating sub-agents, and completing tasks in parallel. And through powerful Xcode tools, you can direct impactful work like localization and accessibility with a single prompt. This app is really starting to come together. For sure! The analytics look great, and the charts really help us see our progress at a glance. Using Xcode made it easy to get off the ground quickly, and there's still so much that we could add. Throughout this session, Xcode supported how each of us needed to work, and kept us in the loop at each step.

With Xcode, you can work the way you want to with agents whether that's exploring, building, refining, or orchestrating. Let's reflect on everything that we used to build out this new feature. It started with exploration, using Xcode Tools and Apple Document Search to map out the code base and learn about the APIs that we wanted to use.

When it was time to build, we used plan mode to design an architecture before writing any code, and relied on queued messages and agent questions to align with the agent on the ideas.

Once we had a prototyped feature, we used Xcode's Build, Preview, and Test tools to verify our work.

When we refined the UI, we attached images to express ideas, inline Annotations to guide changes grounded in the source code, and Previews to verify the appearance.

And finally, we orchestrated larger goals, leveraging tools for localization and accessibility, with sub-agents working in parallel.

Here's what you can do next. Download Xcode 27 and start using agents on your own project. Explore the agentic tools available in Xcode, add your own, and check out the "Create UI Prototypes using Agents in Xcode" and "Translate your app with agents in Xcode" sessions for a deeper dive into the concepts we discussed today. Now we both have time to head to the gym and test out the new features. Meet you there! Thanks for watching!