WWDC26: Coding Intelligence for Beginners Group Lab - Q&A
Direct answers from Apple Engineers during WWDC26
Coding intelligence changes the way developers move from idea to implementation. The panel framed agents as a way to explore ideas faster, validate work with builds and tests, and keep developers in control while offloading repetitive or exploratory work.
As usual, the goal is simple: make the questions easier to scan, easier to revisit, and easier to connect with real app development problems.
I tried to preserve the original wording and combine related answers where appropriate. However, some inaccuracies or mismatches are still possible.
Enjoy! And subscribe so you don’t miss the next Lab.
How has app development changed with coding agents?
Agents make it easier to turn rough ideas into something concrete.
The panel described a workflow where developers can ask an agent to help create a spec, iterate on that spec, and then use it as a shared description of the feature being built. That makes intent more explicit than it often was in older workflows.
Agents also reduce the cost of trying ideas. If a path looks expensive, you can ask the agent to explore it, generate a prototype, validate it, and even discard it if it is not right.
The biggest shift is not just faster code generation. It is that agents can verify their own work with builds, tests, previews, and other tools, which lets developers spend more time on creativity, product direction, and judgment.
Where is the best place to learn slash commands like /plan?
Type / in Xcode’s coding intelligence interface.
Xcode can show compatible slash commands that the current agent provides, along with Xcode-provided skills. You can also ask the agent directly what commands it supports and what each command does.
The panel’s practical advice was to experiment. Try the commands, ask the agent what workflows are available, and see what each one changes in your process.
What unique advantage does Xcode’s built-in coding intelligence provide over external AI agents?
Xcode has Apple-platform context that generic external agents do not automatically have.
The panel highlighted several areas: project understanding, SDK and documentation awareness, Apple-platform best practices, and direct access to Xcode tools for build, validation, previews, UI rendering, and interaction.
Xcode can also expose Apple ecosystem data and workflows such as crash information, localization guidance, and platform-specific validation. The preview system is especially important because it lets the agent inspect and reason about UI, not just text.
Another advantage is onboarding. Xcode provides a strong default setup: planning mode, useful built-in tools, good base guidance, and an extensible plugin story. That gives beginners a running start while still supporting advanced workflows.
Does Xcode 27 show how many agentic resources are being consumed while a request is running?
Not directly in the Xcode UI.
The panel said that most agent providers expose slash commands for this. One command usually reports the current state of the main context window, while another reports usage or cost so far.
Those are different numbers. Context-window fullness tells you whether the agent is getting close to compressing or summarizing context. Usage or cost tells you something closer to what you have consumed financially or against a quota.
If developers want this surfaced directly in the Xcode UI, the panel recommended filing feedback with the desired placement and use case.
Can the Xcode AI agent read or search implementations from other local projects?
Yes, but access is controlled.
If the other project is part of the same Xcode workspace, Xcode can naturally expose that context to the agent. Workspaces are the recommended way to bring multiple projects together when they are part of the current task.
For files outside the workspace, you can provide paths or references and grant access as needed. Xcode uses permission prompts by default so the agent gets what it needs without having unrestricted access to everything.
There is also a managed security mode in Xcode settings, described as an early preview, that can gate agent actions at the file-system level.
The important principle is that the developer remains in control. The agent can request access, but you decide what it can read, move, copy, delete, or modify.
How can beginners understand code that an agent wrote for them?
Ask the agent to explain its work.
The panel suggested several practical workflows: ask “why did you do that?”, request a Markdown or HTML report, ask for a summary after each completed task, or configure an AGENTS.md file so the agent always explains its changes in a format you prefer.
Plan mode is also useful because it lets you understand the proposed approach before code is changed. You can review the implementation plan, challenge assumptions, and guide the agent before it writes a lot of code.
Another strategy is to give the agent partial structure: define the protocol, type names, properties, or comments that describe intent, then let the agent fill in the implementation. That keeps you closer to the architecture while still getting help with details.
For learning, agents can also generate diagrams, architecture documents, quizzes, or explanations tailored to how you learn.
What common mistakes do coding assistants make that beginners may not catch?
Agents can misunderstand your assumptions.
Sometimes they produce something that works but is not maintainable. Sometimes they miss context. Sometimes they take shortcuts that appear to finish the task but do not actually satisfy the intent.
The panel called out “cheating” as a subtle failure mode: an agent might rationalize away a failing test, claim something only fails because of a debug configuration, or otherwise explain why incomplete work is acceptable. If you would not accept that explanation from a coworker, do not accept it from the agent.
Validation helps. Strong types, compiler errors, tests, previews, live issues, and build tools give the agent fast feedback before it hands the work back to you.
Is there a way to undo everything an agent changed?
Yes, but the best workflow depends on your project setup.
You can ask the agent to undo its work or return to the previous state. Agents usually understand their own recent changes well enough to revert them.
Xcode also tracks history across turns when the project has a Git repository initialized. You can open the history view, move back one turn, and revert to the state before the agent’s last action.
The panel strongly recommended using Git even for solo projects. Git is not only for teams. It gives you a safety net, a way to recover from mistakes, and useful history that agents can also use to understand why changes were made.
How should an experienced iOS developer with little AI-coding-assistant experience build the skills expected by modern engineering roles?
Start small and bring your existing experience with you.
The panel recommended using agents on tasks you already know how to do: small bugs, small features, or low-risk refactors. That lets you compare the agent’s output against your own expectations and build confidence.
As an experienced developer, your judgment is valuable. You can guide the architecture, identify bad assumptions, review generated code, and teach the agent your preferences.
You do not need to hand over all control. You can use agents for planning, exploration, documentation, code search, or architecture review before letting them implement anything.
The recommended session for more workflow ideas was “Xcode agents and you.”
What are the key differences between agent mode and chat mode?
The difference is capability and scope.
Chat mode has access to a smaller set of tools and is better suited to shorter interactions: asking questions, making limited code changes, or getting help with a specific issue.
Agent mode can use a much larger toolset. The panel described it as effectively open-ended: command-line tools, many Xcode tools, context management, subagents, and longer-running work.
Agents can work for much longer time horizons than chat. Chat may answer or edit within seconds. Agents can plan, execute, validate, fix errors, and continue working for much longer tasks.
The panel encouraged developers to move from chat to agents in Xcode 27 because agents can still do small tasks, but they also unlock bigger workflows.
Can local models provide the same Xcode coding intelligence features as cloud models?
It depends on whether you are talking about the model or the agent wrapper.
Xcode can talk to local models, including models running on your Mac or on a local server. In chat mode, a local model gives you the chat experience.
For agentic workflows, you need an agent that can talk to that local model. With ACP support, local or open-source agents can use the same Xcode toolset that cloud-backed agents use.
The biggest difference is model capability. A huge commercial model running on a specialized GPU cluster may reason better than a smaller local model on a laptop. But local models can still be very useful, especially if you give them strong guardrails and good validation loops.
Can I connect Xcode coding intelligence to a local LLM like one hosted by mlx_lm.server in agent mode?
Yes, but approach it through a local agent rather than only chat mode.
The panel pointed to ACP support as the path for this. Open-source tools and wrappers with local model support can act as the agent layer, while the local model provides the inference backend.
The session “Run local agentic AI on Mac using MLX” was recommended as a good starting point for this workflow.
What happens to my code when it is accessed by a third-party LLM through Xcode?
Apple does not see those requests.
When you configure a third-party coding agent or model provider, the request goes directly to that provider. You need to read that provider’s terms, privacy policy, and account settings to understand whether your code or prompts can be stored, retained, or used for training.
The panel emphasized that developers are in control of choosing providers and provider settings. If you send code through Feedback Assistant, Apple can see what you intentionally included in the feedback report, but normal coding-agent requests go to the selected provider, not to Apple.
What is the best way to work with AI in Xcode while offline, such as on a train commute, without a huge Mac?
Use local models and local agents for offline work, and plan ahead when you can.
The panel suggested a hybrid workflow: use a larger cloud model before you go offline to help plan the work, write requirements, and set up assumptions. Then, while offline, use local agents and local models to implement or continue the work.
Have the local agent write down assumptions and decisions in Markdown files. When you are back online, ask a larger model to review those assumptions and check whether they still make sense.
Xcode also makes it possible to configure multiple agents and models, then switch between local and cloud-backed workflows depending on whether you are online.
If I already use Claude Code in Terminal and barely open Xcode, what am I missing?
You may be missing the Xcode-specific experience layer and tools.
Terminal workflows are powerful, but they are mostly linear text streams. Xcode can provide a richer nonlinear UI around agent work: code editing, previews, build results, issue navigation, diffs, history, project context, and platform-specific validation.
Xcode also exposes Apple-platform tools and context to the agent. That includes previews, Xcode build and validation tools, project understanding, and integration with the IDE experience you already use to ship Apple-platform apps.
The point is not that terminal agents are bad. It is that Xcode can combine agentic coding with the Apple development environment, which matters when building apps for Apple platforms.
Is it possible to use local AI models for coding intelligence with Xcode 27?
Yes.
The panel pointed developers to the “Run local agentic AI on the Mac using MLX” session as the best place to start. Local models can run on your own Mac or local hardware, and with the right local agent setup they can participate in Xcode’s agent workflows rather than only simple chat.
The key distinction is that the local model is just one part of the system. To get agentic behavior, you need an agent wrapper or integration that can use the model and connect to Xcode’s toolset. With ACP support, local or open-source agents can still access the same Xcode-provided tools.
This is especially useful if privacy, offline work, or local experimentation matters to you. The tradeoff is that smaller local models may need more guardrails, stronger validation, and clearer prompts than large cloud-hosted frontier models.
Is there a way to use Apple foundation models as the agent for Xcode coding intelligence instead of Anthropic, OpenAI, or Google?
The panel pointed back to the local agent and local model story.
If the goal is to avoid third-party cloud providers for privacy reasons, use local models and local agents. The recommended starting point was the session about running local agentic AI on Mac using MLX.
The Mac is a strong platform for this. Even a single modern Mac can run useful local workflows, and more powerful Mac hardware can run larger models.
🏆 Acknowledgments
A huge thank-you to everyone who joined and asked practical questions about agentic workflows, slash commands, Xcode context, local models, privacy, undo, Git, validation, learning with agents, chat versus agent mode, and offline development.
Question acknowledgments: Pichaya Triys, Jason Chung, Harry 3, Juto Art, Tammy Santana, Florentine F, UJ, Interferon, Ants Crashing, Stuff MC, Jay Rooden, Ron Learns, and the online WWDC audience who submitted and upvoted the remaining Coding Intelligence for Beginners questions.
Finally, a heartfelt thank-you to Angelica, Nathan, Ken, Jerome, Kevin, and the teams behind the scenes for explaining how beginners and experienced developers can get started with coding intelligence in Xcode.