By now you’ve probably heard the term “vibe coding.” Coined by former OpenAI founding team member Andrej Karpathy in early 2025, the phrase describes a style of development where you “fully give in to the vibes, embrace exponentials, and forget that the code even exists.” In practice, it means building software primarily by describing your intentions to an LLM instead of carefully planning specs and architecture.

The results can feel magical. They can also hide serious problems. Karpathy’s own tweet even described some of the problems that most seem to have ignored:

There’s a new kind of coding I call “vibe coding”, where you fully give in to the vibes, embrace exponentials, and forget that the code even exists. It’s possible because the LLMs (e.g. Cursor Composer w Sonnet) are getting too good. Also I just talk to Composer with SuperWhisper so I barely even touch the keyboard. I ask for the dumbest things like “decrease the padding on the sidebar by half” because I’m too lazy to find it. I “Accept All” always, I don’t read the diffs anymore. When I get error messages I just copy paste them in with no comment, usually that fixes it. The code grows beyond my usual comprehension, I’d have to really read through it for a while. Sometimes the LLMs can’t fix a bug so I just work around it or ask for random changes until it goes away. It’s not too bad for throwaway weekend projects, but still quite amusing. I’m building a project or webapp, but it’s not really coding - I just see stuff, say stuff, run stuff, and copy paste stuff, and it mostly works.

The Seduction of Vibe Coding

You ask, the model creates. It’s hard not to get hooked. I recently revisited my very first iOS app, a winter weather forecast app I built in 2012 using Objective-C. It had long since been removed from the App Store due to neglect, and the project had reached a point where Xcode could no longer build it. The biggest issue I found is that the source code for a particular graph view had gone missing. I had known about this for a couple years and considered whether I could reverse engineer it based on its API and how it was used. I knew it was possible, but the task was daunting and likely to take considerable time.

I decided to turn to Claude Code. I described the issue in a couple sentences, and after just a few minutes, Claude had rebuilt the missing file and simultaneously breathed life into an app that had been dead for a decade.

That experience captures the intoxicating appeal of vibe coding perfectly. Problems that once required hours of searching through Stack Overflow posts, Apple documentation, and old commit histories can now be solved in minutes just by asking. Entire categories of friction in software development suddenly disappear. The effect is especially dramatic for experienced developers, because you can feel the leverage immediately.

In a way, it’s like playing a slot machine. You pull the lever, lights flash, bells ring out, and you wait a few moments hoping to hit the jackpot. Then the model spits out hundreds of lines of code, the app compiles, your feature works, and your brain gets the same little dopamine rush as if you were watching coins pour out of a slot machine. You feel incredibly productive, powerful even. But like a jackpot in Vegas, the excitement can obscure the looming tax bill that comes due later.

Lost in Translation

Human language is inherently ambiguous. During the process of bringing my weather app back to life I decided I wanted to bring it up to modern standards by converting it from Objective-C and UIKit to Swift and SwiftUI. I wasn’t asking for any new features or changes, just a 1-to-1 port. So I prompted the model with a seemingly simple, straightforward request: Rebuild this project in Swift and SwiftUI. Sure enough, 12 minutes later I had a fully working Swift/SwiftUI version of my app.

But — much to my surprise — it wasn’t exactly what I thought I had asked for. The model hadn’t just done a 1-to-1 port. It had reimagined the entire app from scratch with an entirely new user experience. I hadn’t specified that I didn’t want changes beyond the language update, so the LLM took it on itself to make the app look and feel more modern.

At first, it felt miraculous. The redesigned experience was honestly better than the original app I had built years earlier. But the deeper I dug into the implementation, the more cracks appeared. Important functionality was missing. Existing forecast parsing logic had been discarded. Some views were rendering incorrect data. The app looked complete long before it actually was.

Details Matter

Engineering involves caring about and understanding the details of how a thing works. In a production system, the choices we make can have a huge impact on our app’s performance or security. How do we structure our data? What database do we choose for local storage? How do we architect our API interaction layers? Without understanding these details, the choices you make could result in your app’s performance being greatly degraded or its security compromised.

As an example, consider an app related to finance and real-time trading analysis. This is a scenario where we need high throughput database writes and guaranteed data integrity. An engineer intuitively knows and understands this, but a model may choose something that works but will never scale. A database choice that works perfectly during development with a few hundred records may completely collapse once thousands of real-time updates begin competing for writes.

An experienced engineer develops intuition around these tradeoffs because they’ve lived through the consequences of getting them wrong. They know SQLite with proper indexing and transactional batching may outperform a more fashionable abstraction layer in a write-heavy environment. They understand why eventual consistency may be acceptable for social media likes but unacceptable for financial transactions. They recognize that an ORM convenience feature generating dozens of hidden queries can quietly hinder performance at scale.

In software engineering, maintaining systems over time is often more challenging than building them. Production software accumulates edge cases, legacy integrations, and historical decisions that future developers must understand. Code generated through pure vibe coding can quickly become difficult to reason about, because no developer ever formed a strong mental model of how the system actually works. Debugging becomes slower, refactors become riskier, and eventually the codebase turns into something the developer is afraid to touch.

This is where the distinction between coding and engineering becomes impossible to ignore. The hardest part of building quality software is understanding the invisible constraints beneath the surface: scalability, fault tolerance, latency, synchronization, security, maintainability, operational cost, and long-term evolution. Details matter because production systems eventually expose every shortcut.

Security Isn’t Automatic

Ask a model to integrate a third-party API into a mobile app, and there’s a decent chance it will place the API key directly inside the client application bundle. The feature works. The demo succeeds. But the security model is fundamentally broken because the model is optimized for functionality, not operational safety.

This is a recurring pattern with AI-generated software. The model will often choose the shortest path to a working implementation, even when the path violates basic security principles. Authentication tokens end up stored insecurely. Database rules become overly permissive to avoid access errors.

The problem is deeper than isolated mistakes. Security engineering requires an adversarial perspective. It requires thinking not just about a software’s intended use but also about how it could be misused or even attacked. A secure system must survive both unexpected input and various intentional bad actions. Current AI models won’t make these considerations unless guided by a knowledgeable engineer who understands the risks.

Even more dangerously, insecure code is often indistinguishable from secure code to an inexperienced developer: It’s easy to assume that when the model outputs working code, it’s secure by default — but this is often not the case. What may appear to be production-ready on the surface can hide severe vulnerabilities underneath.

Finding A Middle Ground

Vibe coding vs. engineering is not a binary choice — it’s more like a slider. Engineering takes time, research, and careful consideration. Every time you prompt the model, you’re figuring out how to adjust that slider. In some instances, you may not want to spend the time nailing down all the engineering answers, and it can be helpful to let the model fill in the blanks and see where you land.

There’s also incredible value in iteration. Successful AI-assisted development doesn’t necessarily begin with a fully engineered specification — it begins with exploration. You start with a rough idea, see what comes back, and then start tightening the screws. The first prompt might be pure vibe coding: “Build me a real-time stock screener app with live charts and alerts.” The result may be messy, insecure, or architecturally questionable, but it gives you something incredibly valuable: a concrete starting point. Once you have that, engineering can begin.

From there, the workflow shifts. You stop asking the model to simply “build the thing” and instead guide it through increasingly specific engineering concerns. Replace polling with WebSockets. Move API keys server-side. Refactor the persistence layer to support high-frequency writes. Add retry handling and offline support.

You begin iterating not just on features but on correctness, performance, and security.

The Future Still Needs Engineers

Vibe coding is an incredibly powerful concept, but it is not a replacement for engineering. LLMs act as levers, enabling developers to accomplish more in less time.

In many ways, this is simply the next evolution of abstraction in software development. Early programmers worked directly in assembly and machine code, a painstaking process. Higher-level programming languages changed that. A compiler became a translation layer, converting human-readable intent into machine-executable instructions. Productivity exploded, but the need for engineering did not disappear. We still needed people who understood systems, architecture, performance, tradeoffs, and failure modes. LLMs represent another layer in that same progression. Instead of translating Swift or Python into machine code, they translate natural language into Swift or Python.

The future likely belongs neither to traditional engineering nor vibe coding, but to developers who understand how to combine the two. The ability to move quickly matters. The ability to understand what you’ve built matters even more.

WWDC has come and gone again, with its typical overwhelming amount of information. Siri AI has captured most of the headlines, but WWDC is about a lot more than just the marquee features. We asked some of the folks at MartianCraft what stood out to them from this yearʼs announcements — and they had thoughts. Hereʼs what some of our team had to say.

App Store Improvements and Expanded Surface Area for Apps

“I’m evaluating the OS 27 generation through a dual lens: expanding our clientsʼ App Store footprint and equipping our senior engineering teams to build smoother, frictionless user experiences.

“The sessions Enhance your presence on the App Store and Whatʼs new in Apple In-App Purchase outline exactly how the new subscription suites and rich media asset placements offer practical marketing frameworks to scale organic discovery right out of the new Asset Library.

“On the technical side, the updates detailed in Explore advanced App Intents features for Siri and Apple Intelligence and Discover new capabilities in the App Intents framework push intent architectures much deeper into iOS 27 and macOS 27. By leveraging these new App Schemas, our developers can ensure a clientʼs core app experience seamlessly handles background execution and surfaces context via Live Activities. Navigating these concurrent storefront upgrades and mandatory system intents will be the key to keeping our clientsʼ brands visible, discoverable, and highly effective this cycle.”

— Jana Allen, Project Manager

Laying the Groundwork

“WWDC26 brought a lot of quality of life improvements to all the Apple platforms. While those are great, it did lend itself to smaller feature improvements compared to previous years. A lot of things that I’m excited about relate to Xcode 27 updates and the stability and improvements to the various operating systems.

“I think this year provides a lot of ‘delayed excitement’ for users and developers alike. It seems like Apple is laying the groundwork for foldable devices, touchscreen Macs, and many more niceties that will be announced in the coming months and years — and those devices provide a lot of excitement for us and how we’ll build and deliver apps.”

— Cory Bohon, Team Lead and Senior iOS Developer

Quality of Life Improvements

“As is always the case, I find myself most excited about the small quality of life improvements Apple has made across language, tool, and library updates. There are too many to list, and Iʼm sure I’ve missed many of them, but here’s a sample of the ones I’ve seen so far.

“Swift adds support for memberwise initializers that take private properties into account, removes the requirement to wrap any/some optional types in parentheses, allows async calls to be made from defer blocks, provides more concise availability attributes, and finally gives us a clean way to specify modules when there are naming collisions.

“Iʼve written an implementation of Dictionary.mapKeyedValues more than once. Foundation now provides this out of the box.

“Similarly, I’ve written numerous custom collection and list view reordering implementations over the years. Figuring out how to re-create jiggle mode and handle drag previews in the early days of UIKit was fun, but it will be nice to have this built in to SwiftUI. The updates to AsyncImage might actually make it usable. The improvements to toolbar item creation and positioning will simplify a ton of fiddly code.

“Xcodeʼs revised layout looks to be well thought-out to reduce the number of clicks required to perform common actions. The device hub, too, looks to be the result of deep thinking about how we actually use simulators and devices during development and streamlines a lot of interactions. Subtler predictive errors and warnings will reduce distractions that break coding flow. Even something as seemingly trivial as the new project creation flow will be helpful for those times that I want to try out an idea on a clean slate and donʼt want to lose my train of thought to configure project details that will ultimately be unnecessary.

“These changes (and many more like them) will smooth out innumerable small, daily points of friction, allowing me to focus on what Iʼm building. The best of them will quickly become so automatic that I’ll forget the old ways ever even existed.”

— Beau Bolle, CTO

Swift Beyond Apple Platforms

“I’m sure most of the big platform changes and AI stuff is drowning out some other, more subtle announcements. What I find fascinating is the improvements and expansion of the Swift language driven by the open source community. It’s easy to associate Swift with Apple-specific platform development, but thereʼs so much going on with other platforms (Linux, embedded) and enhancements for C/C++ and Wasm interop. Super cool to see the adoption of Swift continue this path.”

— Brian Buck, Senior iOS Developer

Design Iteration

“Many designers will likely welcome the new slider in Settings to adjust the Liquid Glass effect, a big win for accessibility. There were also other refinements to last yearʼs design revamp that didnʼt get as much attention, but which surface some interesting UX tradeoffs:

• Uniform toolbar: The floating actions often separated controls from the content surface, creating additional visual layers and fragmentation in the UI. While this approach can look great in static mockups, it sometimes competes with the primary content rather than supporting it. The new updates suggest a move back toward more cohesive, integrated toolbars that prioritize hierarchy and content clarity over visual embellishments.
• No more floating sidebar: To follow the same theme, the floating sidebar appeared to be designed more as an added ornamental layer to the UI. As a structural component, it adds visual complexity without a clear benefit.

“Overall, itʼs encouraging to see Apple iterating on these design decisions and responding to usability feedback. Even small refinements signal an important reminder: Strong UX is built on clarity and hierarchy first, not just novelty.”

— Meghan Dever, Designer

New Siri and AI Tooling

“AIʼs greatest strength emerges when it has access to rich, detailed data. The new Siri — powered by Gemini — will finally be able to leverage the vast amount of personal data on-device, delivering truly magical experiences and insights for everyday tasks and whatever life throws at you. This will be the moment that convinces iOS users that AI is an indispensable tool.

“I havenʼt watched any sessions yet beyond the general Xcode and Swift ones. Even so, the improvements around AI tooling are a strong indicator of how central AI is becoming to almost every aspect of software engineering. Swift continues to mature and is gaining meaningful traction beyond Appleʼs personal device ecosystem.”

— Philipp Kinschel, Senior iOS Developer

SwiftData Improvements

“What stood out to me are the changes to SwiftData. Although the session was relatively short, the improvements are exciting.

“Most notably, ResultsObserver will allow developers to decouple SwiftData from SwiftUI by allowing observable types to handle store changes. This should reduce or eliminate the need to perform awkward synchronization between SwiftUI Query results and types used for manipulating that data.

“@Query now supports sectioned fetches via its sectionBy parameter. This allows developers to more easily structure sectioned views, such as List, according to a grouping requirement.

“Finally, developers can now store types that conform to Codable via @Attribute(.codable). However, this should be used carefully because such attributes are not supported when it comes to filtering, sorting, and migration. This allows developers to store external types like MKMapItem.Identifier, a type owned by Apple.”

— Nick Kohrn, Senior iOS Developer

AI Tooling and Agentic In-App Features

“The thing that stands out the most to me this year is just how much Apple is leaning into AI for developers, both to build apps and to implement features inside your apps. Xcode 27 picks up right where Xcode 26.3 left off in terms of agentic coding functionality. Itʼs no longer just a feature relegated to a sidebar, but front and center with major improvements.

“Probably my favorite announcements are the improvements to the Foundation Models framework and the new Evaluations framework. Implementing LLMs inside your app today probably requires a third party framework or rolling your own agent loop to support tool calling. Itʼs not particularly challenging to build, but it is a significant amount of work. Apple has greatly simplified this process by building support for third party models right into the Foundation Models framework. Once I’m able to work these new changes into my apps, I’ll be able to rip out A LOT of code.

“The Evaluations framework was also a welcome surprise. When using LLMs it can be a bit tricky to get your prompts and context just right to get the output youʼre looking for. The Evaluations framework lets you automate testing of these results in the same way you create unit tests. It helps you evaluate whether your results are getting better or worse when you make changes to your prompts or model. For one project, I even vibe coded a helper app for just this sort of evaluation. Iʼm delighted to soon be able to throw all that out and implement the much more robust Evaluations framework.”

— Josh Levine, Senior iOS Developer

CarPlay Improvements

“The Rev Up Your CarPlay App session is of particular interest to me for my recent work on a CarPlay-enabled navigation app. A challenge I faced was working within the narrow confines of the allowed CarPlay UI. CarPlay under iOS 27 adds the concept of Navigation Panels, which give more fine-grained control over what you can present and how it is presented. Another interesting feature is the Route Sharing option, which allows you to share the current route information with a more sophisticated vehicle system, allowing for a richer experience and more pervasive integration with the vehicleʼs available screens and driver assistance awareness.”

— Josh Nozzi, Senior iOS Developer

Steady Improvement All Around

“Two themes that stood out to me from WWDC26 were stability and plumbing. Last year, Apple introduced ambitious ideas like Liquid Glass and Apple Intelligence, but they werenʼt quite ready for prime time in practice. This year feels like a more complete implementation of those ideas, with progress in both polish and capability. The refinements to Liquid Glass address usability issues that showed up early on, and Appleʼs Foundation Models on-device and on Private Cloud Compute are more capable in how they can be used across the system.

“More importantly, Apple isnʼt just improving the user-facing features; itʼs building the infrastructure layer for developers to depend on. App Intents continue to evolve into the interface between apps and the system, making app content and actions available across Siri, Spotlight, Shortcuts, and Apple Intelligence. The natural language shortcut creation demo showed how this is being used. Overall, WWDC26 feels less like a flashy release and more like a stabilization and enablement year, where the focus is on making last yearʼs ideas usable and exposing the right primitives for developers to build on.

“A few things stood out beyond the core platform themes:

• Swiftʼs reach continues to expand, now reaching into the kernel.
• Dynamic Profiles allow models, tools, and instructions to be swapped mid-session while maintaining a single continuous transcript.
• Core Spotlight tools can be used to support LLM-based search within apps.

“Some of the sessions at the top of my list:

• Whatʼs new in Swift
• Whatʼs new in SwiftUI
• Whatʼs new in the Foundation Models framework
• Build agentic app experiences with the Foundation Models framework
• LLM search using Core Spotlight
• Build intelligent Siri experiences with App Schemas
• Explore advanced App Intents features for Siri and Apple Intelligence”

— Hardik Patel, Senior iOS Developer

Unified Design Direction

“Appleʼs refinement of Liquid Glass at WWDC26 highlights an important UX principle: Visual innovation should never come at the expense of usability. Liquid Glass was met with mixed responses when it first was revealed. This feedback included concerns about legibility issues and excessive visual noise caused by the new transparency effects. WWDC delivered a response to said feedback by adjusting the system to improve readability and by introducing controls that allow users to customize the level of Liquid Glass transparency. This shows that Apple has their finger on the pulse of their consumer base, showcasing their understanding that clarity and comprehension are more important than purely aesthetic trends like simple glassmorphism and layered visual effects.

“The update also reflects a broader shift in UX design philosophy. Rather than delivering a single, fixed experience, designers are increasingly expected to produce flexible systems that adapt to individual user needs and preferences. Features such as accessibility settings, Dynamic Type, motion reduction, theme customization, and even AI-centric personalization — all of these point toward a future where users have greater control over how interfaces look and behave. As a result, modern UX design is becoming less about designing static screens and more about designing adaptable experiences that focus on consistency, accessibility, and personal choice.”

— Jacob Rems, Designer

Names Matter

“If you’re going to watch any of the WWDC26 videos, you must also watch all 15 minutes of Craft clear names for features and labels in your app.”

— Trevor Squires, Senior iOS Developer

More Capable Siri and Overall Refinements

“This year I am excited to see that Apple has seemingly focused deeply on overall refinement across its platforms. These are platforms I spend the majority of my waking hours using, and every bit of friction creates discomfort throughout the day. For me, Appleʼs platforms provide the best overall experience, so improvements are always welcome.

“To get a sense of how much refinement has been made, check out this article by Jonathan Reed at MacStories: WWDC 2026: Small Details and Compatibility Lists. I’m confident it’s not a complete list of enhancements, but there are a ton of valuable callouts to paint the picture.

“On the new feature side of things, I am very excited to see Siri become more capable and human-like. While watching the keynote this year I had a flashback to 2011 when Siri was first introduced. Back then we saw some really cool interactions, like creating calendar events, setting reminders, and sending messages all with voice commands.

“These were absolutely amazing features at the time, but over the years it really became obvious that you had to know how to use Siri. Completing some of these tasks requires a subset of language in specific arrangements, and it is both limiting and frustrating when you fumble it. With Siri AI we should be able to speak to Siri like we speak to a human and anticipate that it will do the thing you asked, regardless of nuanced phrasing and taking into account context around the request.

“To see the extent that Apple has furthered the story with regards to Siri and App Intents, you can check out the session Explore advanced App Intents features for Siri and Apple Intelligence and the doc Adopting App Intents to support system experiences. I really hope we see widespread adoption of these features!

“As always, thereʼs so much packed into WWDC, and this is just scratching the surface. I am excited to continue learning more.”

— Chris Wagner, Team Lead and Senior iOS Developer

Wrapping It Up

WWDC26 delivered a lot of refinements and a heavy dose of AI tooling for building apps and app features. Apple has continued to refine the experience for users and developers alike. Our team is already hard at work digging into these technologies and figuring out how they can help our client projects. If you’re as excited as we are about what’s next, reach out — weʼd love to help you take full advantage of everything Appleʼs latest platforms have to offer.

Every June, Apple’s Worldwide Developers Conference gives us a look at the road ahead — the place where the hardware we know meets the software we’re about to build. At MartianCraft, we’ve been shipping apps on Apple’s platforms since the earliest days of Mac OS X and iPhone OS, so we always settle in for the keynote with a notebook and a strong cup of coffee, our Susan Kare-designed blanket, and our Throwboy Mac pillow.

If WWDC25 was about unifying the platforms under a shared look and a shared version number, WWDC26 is about making them smarter, more performant, and user appealing.

This year’s headline is unmistakable: The long-promised, deeply personal Siri finally arrives as Siri AI, and the next generation of Apple Intelligence spreads into nearly every app you touch.

For those of us who write the apps, there’s an equally big story in the developer tools — new AI frameworks, on-device model support, and agentic coding baked right into Xcode. Let’s unpack the announcements platform by platform.

Welcome to Version 27

The unified version number that arrived last year is sticking around — and ticking up. iOS, iPadOS, macOS, watchOS, tvOS, and visionOS all move to 27 this fall.

After a decade-plus of mismatched numbers, having one number to rule them all continues to make life simpler for everyone: Users know what they’re running, and developers get a cleaner story about feature parity across the ecosystem. The betas are available to developers today, with a public beta arriving next month and the free user-facing updates shipping this fall.

Siri AI: The Assistant We’ve Been Waiting For

Siri AI is not a coat of paint on the old assistant — it’s a rebuild from the ground up, with Apple Intelligence at its core.

Three capabilities define it.

First, personal context understanding: Siri can reason across your messages, emails, photos, and more, so you can ask it to dig up the restaurant a friend recommended last week or the confirmation number buried in an old email.

Second, onscreen awareness: It understands what’s on your display and can act on it — read a text about a potluck, generate ideas for what to bring, and drop a recipe into Notes without you leaving the conversation.

Third, broad world knowledge: Siri can now go out to the web and answer open-ended questions, then keep the thread going with natural follow-ups. You can ask it about current events, and it can search through news articles to find exactly what you’re talking about and add to the conversation.

It shows up everywhere you’d want it. You can still say “Hey Siri,” but on iPhone you can also press the side button or swipe down from the Dynamic Island for an in-depth answer.

On iPad and Mac, Siri lives in Spotlight and in system context menus, so you can Control-click an image, file, or selection and just ask.

On Apple Vision Pro it becomes a 3D presence you can place in your space and talk to by looking at it. And it follows you onto Apple Watch, CarPlay, and AirPods.

There’s also a dedicated Siri app that keeps your conversation history in one place and privately syncs it across devices via iCloud — start a chat on the Mac, finish it on your iPhone.

Visual Intelligence expands beyond iPhone to iPad, Mac, and Vision Pro, and a new Siri mode in the iPhone Camera lets you point at the world and get answers — split a bill with Apple Cash, pull nutrition info off a plate of food, and more.

Add to that genuinely useful writing tools that draft and revise text almost anywhere you type (and even match the tone you usually use with a given recipient), plus more expressive voices and noticeably sharper dictation on Apple’s newest on-device model.

As always, Apple’s pitch leans hard on privacy. Siri AI runs on a mix of on-device processing and Private Cloud Compute, with requests handled in a way Apple says keeps your data inaccessible to anyone — itself included — and open to outside verification. Siri AI is available for developer testing now (you can sign up for the beta in iOS, macOS, iPadOS, or visionOS version 27) and arrives as a user beta later this year, starting in English only.

Apple Intelligence in the Apps You Use Every Day

Beyond Siri, the next generation of Apple Intelligence will quietly thread itself through the stock apps. A few examples that stood out:

• Photos: Spatial Reframing. Improve a shot’s composition after you’ve taken it — handy for the photos you didn’t get quite right in the moment.
• Safari: Notify Me. Ask Safari to watch a web page and ping you when something changes, like a restock or a price drop.
• Image Playground: Photorealistic generation. New styles, including high-quality photorealistic images for when the cartoon look won’t do.
• Messages: One-tap suggestions. Context-aware shortcuts that, say, spin up a reminder or a note straight from a conversation.
• Mail: A rebuilt, more relevant, smarter, and more reliable search system.

For Developers: Intelligence Frameworks, Core AI, and an Agentic Xcode

This is where the keynote got our attention. Last year, Apple introduced the Foundation Models framework; this year it grows up.

It’s now a single native Swift API that supports more capable on-device models with image input, an option to reach server models, and the ability to define custom skills. Under the hood, the next-generation Apple Foundation Models were built in collaboration with Google and its Gemini models.

Two details are worth circling for indie developers: Through the new language model protocol, you can plug in models of your choice — Claude, Gemini, or anything else that implements it — rather than being locked to one provider.

And developers in the App Store Small Business Program with fewer than two million lifetime downloads can run the next-gen Apple Foundation Models on Private Cloud Compute at no cloud API cost, which lowers the barrier to shipping AI features considerably. The framework also adds Dynamic Profiles to adjust how a model behaves in your app on the fly.

For teams that want to bring their own models, Core AI is a brand-new framework for running models on-device, with an architecture tuned for the unified memory and Neural Engine of Apple silicon — enough to deploy full-scale LLMs locally. And updates to app intents let you wire your app into Siri AI’s personal context, app actions, and onscreen awareness, so your app’s content and capabilities become discoverable across the system.

Then there’s Xcode 27, which brings even more this year for agentic coding. You can now work with agents from Anthropic, Google, and OpenAI directly inside Xcode, with interactive planning, multiturn Q\&A, and a canvas that renders Markdown and shows code changes and previews right alongside the conversation. Crucially, Xcode gives those agents the tools to check their own work — writing and running tests, trying ideas in isolated Playgrounds, verifying visual changes with previews, and driving the simulator through a new Device Hub — so they can run autonomously for longer stretches.

The App Store: New Ways to Market and Get Discovered

Apple is also handing developers more levers to grow. Creative assets let you place rich images and video in the product page header and search results to highlight a brand or a seasonal push, and a new Asset Library in App Store Connect keeps all of that media in one place — reusable across custom product pages and In-App Events, and submittable for review independent of an app update.

Two housekeeping wins worth celebrating: In-App Purchases and related items can now be grouped into a single, unified App Review submission, and apps on the Mac App Store no longer require Intel support — you can ship Apple-silicon-only binaries and stop maintaining multiple builds. (More on the end of Intel below.)

Parental Controls and Screen Time Get Serious

Families are getting a meaningful set of new tools. Setting up a child account enables age-appropriate protections across the system right away, and a Setup Assistant lets parents choose exactly which apps are available and stay in control as new ones are added. Communication Safety — already blurring nudity in Messages and FaceTime for users under 18 — now also steps in on gore and violent content, and parents can require approval for each new contact.

New Time Allowances make it easy to set daily limits across Entertainment, Games, and Social Media, with suggested starting points informed by clinical and child-development experts. Schedules govern which apps are available at different times of day, and Screen Time has been redesigned for an at-a-glance view of usage.

For developers, there’s a to-do: The age-rating questionnaire is being updated in July so you can indicate whether your app has social media features, which determines how it’s sorted into Time Allowance categories. It’s worth checking your apps when that lands in App Store Connect.

Polish, Performance, and the Quiet Wins Across Every Platform

Plenty of the year’s best work is in the details. On performance, Apple cites apps launching up to 30% faster, photos loading up to 70% faster after capture, AirDrop up to 80% faster, and browsing external drives on iPad up to 5x faster — roughly Finder-on-Mac territory. Network transitions between cellular and Wi-Fi are smoother, and search in Spotlight, Photos, and Mail has been rebuilt to be more stable. (As always, treat Apple’s benchmark figures as best-case numbers from their own testing.)

On the design side, Liquid Glass gets a transparency slider in Settings so users can dial it anywhere from ultra-clear to fully tinted, and it adapts to accessibility settings. App icons are sharper. And on the Mac, Apple is reincorporating cornerstones longtime users have missed — a more uniform toolbar, edge-to-edge sidebars, and colored sidebar icons.

A grab bag of additions arriving this fall:

• iCloud Shared Albums get cross-platform sharing with full-resolution support.
• Health adds perimenopause and menopause support in Cycle Tracking, including cycle-deviation notifications.
• Apple Watch gains a dynamic app grid of five Siri-suggested apps, a tap gesture to open Smart Stack widgets, and a consolidated Find My app.
• AirPods get custom EQ, and AirPods Pro 3 can sync heart-rate data through iPhone with expanded GymKit.
• Apple Vision Pro can turn panoramas into spatial scenes for use as personal Environments, with Wi-Fi connections up to 3x faster.
• Apple Maps gets an enhanced Flyover that blends aerial imagery with AI for more detailed visuals.

And, Quietly, the Last of Intel Fades Out

Last year’s recap noted that macOS 26 Tahoe was the final Intel-compatible release. This year the consequences arrive in the toolchain: Xcode 27 is Apple-silicon-only and meaningfully smaller, and the Mac App Store no longer requires Intel builds. If your team is still shipping universal binaries out of habit, this is your nudge — the future of the Mac is Apple silicon, full stop, and the tools now assume it.

The Asterisk: Siri AI and the EU

Not all of this lands everywhere at once. Because of the EU’s Digital Markets Act, Siri AI will not ship in the European Union on iOS 27 and iPadOS 27 when the updates arrive this fall — and there’s currently no timeline for it. EU-based developers won’t be able to test the new Siri AI features for their iOS and iPadOS apps, but EU users will still get Siri AI on macOS 27, visionOS 27, and watchOS 27.

Apple’s framing is a privacy and security argument: It says regulators’ interpretation of the DMA would require giving any third-party assistant deep access to a user’s data and the ability to act across apps, and that it proposed a Trusted System Agent intermediary plus an 18-month phased rollout, which the European Commission declined. Apple also notes that Siri AI and the other new Apple Intelligence features won’t be available in China yet while it works through local requirements. It’s a reminder that, increasingly, where a feature ships is as much a regulatory question as a technical one — something to keep in mind if your audience is global.

Why WWDC Still Matters

WWDC felt a lot smaller this year, with more focused updates specifically around making sure that Apple’s operating systems are at peak performance. Those updates are welcome in a world where we’re always itching to go faster, add more features, and revisit and perfect existing features.

In a year of constant point releases and quiet feature drops, WWDC is still where Apple states its intentions out loud. This year those intentions are clear: Make the assistant genuinely useful, push intelligence into the everyday apps, and — importantly for us — give developers real, flexible AI building blocks and an Xcode that can pull its weight alongside coding agents.

The fact that you can bring the model of your choice, including Claude, and that small teams can tap Apple’s models at no cloud cost, says a lot about who Apple wants building the next wave of apps.

At MartianCraft, we’re already pulling down the betas, kicking the tires on the intelligence frameworks, and thinking about how app intents, Siri AI, and on-device models change what our clients’ apps can do. If you’re wondering what these tools mean for your product — or you want a partner to help you build it — we’d love to talk. Reach out.

WWDC is once again upon us. For Apple developers, it marks one of the busiest and most exciting weeks of the year as new SDKs, frameworks, tools, and platform updates arrive all at once. Beyond the keynote there will be a steady stream of video sessions, new documentation to review, and builds to test throughout the week.

What We’re Expecting

At the highest level, we expect the usual platform-wide refresh: iOS 27, iPadOS 27, macOS 27, watchOS 27, visionOS 27, and updates across the rest of Apple’s ecosystem.

Last year’s major story was Liquid Glass, Apple’s broad design update across all its platforms, built around a new translucent material. Opinions of the design language have been mixed, so it’s likely we’ll see further refinements to address the most common complaints, such as readability and contrast.

Earlier this year, Xcode 26.3 introduced support for agentic coding right within the app. It’s a good first step but still lags behind tools like Claude Code or Codex. It’s likely that Xcode 27 will bring further improvements to its agentic coding abilities.

Siri Is Likely the Biggest Story

While developers will care deeply about the frameworks and tools, the broader story of WWDC26 is likely to be about Siri, as a major Siri overhaul is widely expected to be unveiled. At first glance this may appear to be a story for users, but it’s likely to be just as significant to developers. Siri could become a new interaction layer across the platform — becoming another surface area for apps in the same way widgets, notifications, Spotlight, Shortcuts, and Live Activities have become.

What We’re Hoping For

Beyond the headline features, we are hoping for improvements in the frameworks developers rely on every day.

SwiftData is high on that list. The framework has a lot of promise but is still lacking when compared to CoreData. Some specific areas for improvement revolve around migrations, improved visibility into CloudKit sync behavior, richer querying, more advanced indexing options, and clearer debugging tools when things go wrong.

Swift Charts is another framework where we would love to see improvements. It has already made it much easier to build beautiful, native charts, but many serious apps need more advanced interaction. Pan and zoom support would be a meaningful improvement. Candlestick charts would be valuable for finance and trading apps. More flexible interaction APIs would help teams build chart experiences that feel less like static visualizations and more like real tools users can explore.

On the UI side, we would love to see improvements to customization of some components including search bar, titlebar, and lists. These sound like small things, but they matter for efficiently nailing the details when implementing app designs.

And yes, we are still hoping for Xcode for iPad.

That does not necessarily mean the full macOS version of Xcode running unchanged on iPadOS. Even a focused version for reviewing projects, making small edits, resolving build issues, or continuing agent-assisted development from an iPad would be meaningful.

What We’re Most Excited About

The new Siri will likely consume the headlines, and for good reason. If Siri becomes capable of understanding user intent and orchestrating actions across apps, app intents may become far more important than they are today. Features that previously relied on direct user interaction could become accessible through conversational workflows, making app intents a critical part of the application surface area.

The continued evolution of Xcode and its agentic coding support is also an area to be excited about. In the past year, agentic coding has seemingly taken over the programming world. Xcode 26.3 was a good first step, but we really look forward to what’s next.

And beyond the known and oft-rumored items, there are always surprises, like new frameworks, new controls, or longstanding bugs finally getting fixed.

Regardless of what is announced, WWDC is one of the most exciting weeks of the year for Apple developers. New tools, new frameworks, and new possibilities inevitably create new opportunities — and a long list of ideas we can’t wait to start building.

Humanity continues to move forward, and technology is the driving force that moves us to new horizons. As MartianCraft celebrates its 22nd year in business, alongside the 50 years of Apple, we look back to see what humanity’s past can teach us about our future.

Somewhere in the tall grass of an East African Rift Valley, a couple million years ago, a hand closed around a stone and struck it against another. The flake that broke away had an edge — and that edge changed humanity forever. Not because the tool itself was remarkable, but because of what it represented: a mind that could look at the world and imagine it as it could be, not only what it was.

Every meaningful leap in human history has followed a similar arc: Someone looked at a limitation and refused to accept it.

The 20th century showed that humans, when they put their minds to it, could compress a millennium into a single hundred-year sprint that could drive humanity forward more than they could ever imagine.

The Wright Brothers’ First Flight. Image via Library of Congress.

The Wright brothers’ 12-second flight at Kill Devil Hills (near Kitty Hawk, North Carolina) in 1903 gave way, within a single lifespan, to humans tracking footprints across the surface of the Moon.

Marconi’s crackling transatlantic radio signal in 1901 became the backbone of a global communications network powered by microwaves, twisted copper wires, fiber optics, and satellites.

Alexander Fleming’s accidental discovery of penicillin in 1928 launched a pharmaceutical revolution that roughly increased the human lifespan by 32 years or more.

John Bardeen, William Shockley, and Walter Brattain, the inventors of the transistor. Image via AT&T / Bell Labs. Public Domain.

The invention of the transistor at Bell Labs in 1947 (in large part due to efforts coming out of World War II; see “Chip War” by Chris Miller <hhttps://www.simonandschuster.com/books/Chip-War/Chris-Miller/9781982172015>) was a tiny, quiet thing that set off a chain reaction that would reshape every industry, every government, every household on the planet.

Each of these breakthroughs shared a common element: They didn’t just solve a problem; they expanded the definition of what was possible. And each one demanded a new kind of craftsperson — someone who could wield the new tool not just competently, but with intention and care.

The Dawn of the Personal Computing Revolution

By the mid-1970s, computing had already proven itself indispensable — but only to institutions. Mainframes filled climate-controlled rooms. Terminals were tethered to universities and corporations. The power of computation was real, but it was locked away behind access badges and operator consoles and out of reach to all but a few researchers.

The two “Steves,” Wozniak and Jobs, with their Apple I computer in 1976 at the Homebrew Computer Club. Image author unknown.

Then, on April 1, 1976, in a garage in Los Altos, California, Steve Jobs, Steve Wozniak, and Ronald Wayne signed a partnership agreement and founded Apple Computer Company. It was April Fool’s Day — a fitting birthday for a company whose founding premise sounded to most of the computing establishment like a joke. They thought ordinary people should be able to own computers, and they set out to make that a reality.

MacBook Neo, Apple’s latest computer in 2026. Image via Apple, Inc.

Half a century later, the device in your pocket carries more processing power than every machine NASA used to reach the Moon, combined. Apple’s platforms (iOS, macOS, watchOS, tvOS, visionOS) form the foundation of an ecosystem that touches billions of lives daily. The App Store alone has fundamentally reshaped how software reaches people, how businesses operate, and how developers build their livelihoods. What started as a contrarian bet in a California garage became the single most influential platform company in history.

Today, Apple turns the big 5-0. Fifty years in the making, and they’re still doing what they do best: bringing technology to the masses in a stylish way.

Software as a Craft

Somewhere along the way, the world started treating software like a commodity — something to be produced as cheaply as possible, as quickly as possible, by whoever would do it for the lowest rate. Offshore it. Template it. Ship it fast and fix it later. The prevailing wisdom became about velocity and volume, not vision and craftsmanship.

But software was never a commodity. Not really.

Software is the medium through which modern businesses think, communicate, and serve their customers. A poorly built application isn’t just a technical failure: It’s a broken promise to every user who opens it. A clunky interface, a data leak, a crash at the worst possible moment. These aren’t abstract engineering shortcomings. They’re experiences. They shape how people feel about your brand, your product, your judgment.

The best software has always been built the way the best things in any discipline are built: by people who understand the material deeply, who care about the details others overlook, and who take genuine pride in the finished product. Software development, when done right, is a craft. And like all crafts, it rewards experience, demands discipline, and cannot be faked.

Twenty-Two Years of Crafting

On April 1, 2004, MartianCraft opened its doors — sharing a birthday with the company whose platforms would define our work. The timing was poetic, even if it was intentional. When we started, Apple had yet to enter its most influential years. The Mac was just starting a resurgence, thanks to a massive rewrite to the Mac operating system with Mac OS X. The iPhone was still three years away, the App Store was four years away, and the entire landscape of mobile-first, platform-native software development was way over the horizon.

We were here before the App Store existed. We were building for Apple platforms when “there’s an app for that” hadn’t yet been coined. And for 22 years — from the first iPhone SDK to SwiftUI, from iCloud to on-device machine learning — MartianCraft has been doing the same thing: building exceptional software for clients who understand that quality matters.

That longevity isn’t an accident. It’s the result of a deliberate philosophy. We have never chased the lowest bid, and we have never offshored our engineering. Every line of code that ships is from MartianCraft, written by seasoned developers based in the United States — people who are not just proficient in Apple’s platforms but who are genuine experts, many of whom have been building for these systems since before the iPhone existed.

Our clients are discerning because their products demand it. When the quality of your software is the quality of your customer’s experience, there’s no room for “good enough.” There’s only great.

The AI Inflection Point

All of this brings us to the current inflection point and the answer to a question that dominates every conversation in our industry right now.

Artificial intelligence, and specifically large language models, has arrived with a force that few technologies in the short history of computers can match. Tools like Claude, ChatGPT, GitHub Copilot, and more can generate code, draft documentation, and scaffold entire applications in seconds. The productivity gains are real, the implications are staggering, and, for many in the software industry, the anxiety is palpable.

Will AI replace developers? Is the craft of software engineering on borrowed time?

Here’s what 22 years of software development has taught us: Every major technological shift produces the same fear and the same opportunity.

When the App Store launched, web developers were worried they’d be obsolete. When Swift replaced Objective-C as Apple’s language of choice, a generation of developers feared they’d be left behind. When cloud computing matured, entire categories of infrastructure engineers were told their days were numbered by the onset of “no code applications.”

In every case, the technology didn’t eliminate the need for skilled practitioners. Instead, it raised the bar.

It demanded more judgment, not less. More taste, not less. More understanding of the why behind the code, because the what got easier to produce.

AI is the most powerful amplifier the software industry has ever seen. But an amplifier is only as good as the signal it’s amplifying. Feed it mediocrity, and you get mediocre output at scale. Feed it the expertise of engineers who understand platform conventions — who think in terms of user experience rather than function signatures and who know the difference between code that works and code that’s right — and you get something extraordinary.

This is the future we’re building toward at MartianCraft. Not a future where AI replaces craft, but one where craft is more important than ever. When anyone can generate code, the differentiator becomes the judgment, taste, and expertise that determines which code to generate, how to architect, and why the details matter.

We believe that the crafter behind the tools is important. That skills and experience are what generate the best results. That’s why we use AI as a tool, but never to “vibe code” anything. Our software is hand built, detail oriented, and put through exacting standards that we hold high.

That’s why even the details on our website are thought out and always have a human touch. Articles like this on our site are written by people who are crafting their stories for other humans, edited by humans (hi, Liz!), and have hand-drawn artwork as the chef’s kiss.

The Next Chapter

Fifty years ago, Apple bet that personal computing would change the world. Twenty-two years ago, MartianCraft bet that quality would always matter and that there would always be clients who refused to settle, who understood that their software was too important to hand off to the lowest bidder or leave to an algorithm to decide what’s best.

Both bets paid off. Both continue to.

As we look ahead, the landscape is shifting faster than ever. On-device AI, spatial computing, and platform convergence are creating opportunities that would have sounded like science fiction a decade ago.

The tools are more powerful. The stakes are higher. The margin between great software and everything else continues to widen.

MartianCraft was built for exactly this kind of moment — a moment that rewards deep expertise, principled craftsmanship, and the kind of long-term partnership that doesn’t come from a vendor catalog or an offshored sprint team.

It comes from skilled craftspeople who love what they do and strive for the best products of their work. That’s why we hire people who love the challenge, who push the needle forward. We don’t take the easy way out; we embrace things that are built with sweat and integrity.

We’ve spent 22 years earning the trust of clients who expect the best.

… and we’re just getting started.

AI is everywhere these days. It’s difficult to go a day without hearing something about AI or LLMs. Google searches now include AI overviews, and free services pop up regularly with new AI interfaces to accomplish various tasks. Users can generate images, make art, make music, and, yes, even generate code.

If there’s one thing that history has shown, it’s that ignoring new technology won’t make it go away. More importantly, the early adopters of major advancements tend to pull ahead in related fields.

How You Shouldn’t Use AI

Still, I think it’s important to recognize that what we know as “AI” right now is not true artificial intelligence. We’re seeing exciting new technology that opens up a lot of new possibilities, but it is limited. At this point, most of us have that one friend (or more) that uses AI for everything. While I appreciate capturing the value of tools like AI as much as any tech geek, modern AI is weak when it comes to making decisions within a broader context.

“Building apps in Swift and SwiftUI isn’t quite as easy for AI tools as other platforms, partly because our language and frameworks evolve rapidly, partly because languages such as Python and JavaScript have a larger codebase to learn from, and partly also because AI tools struggle with Swift concurrency as much as everyone else. As a result, tools like Claude, Codex, and Gemini often make unhelpful choices you should watch out for. Sometimes you’ll come across deprecated API, sometimes it’s inefficient code, and sometimes it’s just something we can write more concisely.” — Paul Hudson¹

When it comes to iOS development specifically, what does this mean? It means that AI is excellent at pulling from existing references and resources, known APIs, etc. to create code that compiles and runs (usually) — but that code might not be what you actually need. It may not solve your reported issue, it might be out of date, use deprecated code, use unsafe practices, miss key elements, and so on. To put it simply, don’t trust AI to do your job for you.

Some of you reading this will think to yourself “well duh,” but there will be just as many people who balk or question this statement. “Vibe coding” has been an increasingly popular approach to software development, and while it may have good use cases in my opinion it’s an extremely dangerous path. To be clear, this is not an old man shaking his fist at new technology; rather, this is someone who has already seen vibe-coded apps and features break down and require additional developer time to debug and fix what could have just been written correctly the first time.

A phrase I’ve heard tossed around in software engineering circles is “treat it like a junior developer.” I agree with this sentiment to a degree, but the mindset here matters. It’s important to think about the broader implications of that idea. If you treat your AI tool as a junior developer, that makes you the senior developer. With that comes a few important qualifications to the practice:

• Never ask the AI to do something you don’t know how to do yourself. Why not, you might ask? Well, how would you know if it was done correctly? How would you catch critical mistakes or issues in the implementation? You wouldn’t — and you won’t.
• Review any code an AI wrote as you would that of a junior. Scrutinize it, think of how it fits in the greater context of the architecture, look for common mistakes like memory leaks, redraw loops, etc.. Build it and test that it does what it claims to do.
• Don’t assume or trust that the AI knows the right answer or that it knows something you don’t. If you read the code and your initial thought is “wait, what?”, it’s probably best to be more thorough in your review.

All this to say that the code should be treated as suspect. Because of this, in many cases it might be more time efficient to just do the task yourself.

It’s worth noting that even those companies that have openly embraced vibe coding may be more conservative behind closed doors than their public announcements suggest. Builder.AI, for example, promised a platform that could create apps using vibe coding with no specific expertise required. However, after the company completely collapsed financially (from ~$1.5 billion in value to ~$0), it was revealed that they were using cheap programmers to do the bulk of their coding grunt work, rather than AI. So even a company that wanted to embrace vibe coding found that it was lacking and that they needed human input and developers to finish the job.²

How You Should Use AI

With all that being said, how should we use AI? I’ll be honest, when I first sought to answer this question I found it far more nebulous than I initially expected. I asked around, and for every four developers, I got five answers. There were, however, a few consistent themes in the responses. I’ve come to realize that how (and to what extent) devs use AI is a fairly personal decision, but the bulk of the uses fall into a few categories.

“We can ask it to help break down the problem if we want. We’re still breaking down the problem, we’re still finding the pieces. And so now I actually use AI all day long. I have copilots from GitHub inside of Xcode. … [O]ne of the complaints people have about that is it can’t do like whole apps or like whole views or stuff like that. And I actually like it that way.” — Donny Wals³

Efficiency

The first category that came up regularly was efficiency. AI can look at your project, recognize patterns, and create boilerplate code for you. It can also expand existing patterns if there is a lot of repetitive code required. A good example would be if you need to add another REST API call to your app, you could ask your preferred AI companion to generate the new API based on your existing patterns. You just saved yourself maybe 10-15 minutes of work.

What about a simple SwiftUI view that doesn’t have any special behavior or requirements? AI can do that for you. Need to refactor some old UIKit into a modern SwiftUI view? Probably not an issue. You can even ask your AI companion to review blocks of code for readability, potential risks or bugs, etc. It’s fairly helpful in this regard and can catch things you might overlook.

Additionally, if you use scripting in your development workflow, AI is great at that. The existing documentation and examples for scripting languages are massive compared to that of Swift/SwiftUI, so the AI has a lot more rabbits to pull out of its proverbial hat for that application.

Here’s an important note on all of those uses: Always double check the AI’s work. Again, treat it like a junior developer. It can recognize and copy patterns, but as I mentioned before it doesn’t understand context. The code might work, but make no sense in the broader feature or architecture.

Tests

This one is huge for me. We all love unit testing and the multitude of benefits it provides during large projects. But if you’re like me, you don’t necessarily like taking the time to write unit tests. They can bog you down a bit, and can interrupt your workflow if you’re working on a big task.

This is definitely a place where AI can help. Ask it to write unit tests. Be specific in your prompt for what your expectations are and what you want to test. Let AI generate the bulk of the test, then go in and fine-tune it to your specifications. This is a huge time-saver, and you get the benefits of unit testing-driven development. In addition to writing the tests, you can ask AI to check test failures and quickly identify the cause of the failure. This can be a wonderful tool to save you debugging time.

“Swift Assist serves as a companion for all of a developer’s coding tasks, so they can focus on higher-level problems and solutions.” — Susan Prescott⁴

Debugging and Code Evaluation

Tools like Claude, Cursor, and Copilot can be great for debugging and code review. You can ask the AI to look over your code for any issues, and it will find them. In fact, it will almost always find something. A lot of the time it’s wrong, but it’s also often right, and it can be a wonderful tool.

However, once again, it’s very important to remember that AI doesn’t understand context. It can’t see the bigger picture or understand the overarching architecture of your project. Keep this in mind when you read its feedback. It’s OK to tell the AI when it’s wrong and ask it to remember that, and it’s OK to reject suggestions that would be problematic in ways the AI might not see.

In short, use AI tools to get feedback, but take everything the AI suggests with a grain of salt and carefully consider what its suggestions might do in the broader context of the codebase.

Accessibility

This is a great use for AI, and it supports a best practice that I know many of us sometimes overlook. It can be very easy to write your code and create your user interface without thinking about accessibility features, especially if they don’t affect you directly. This is a workflow you can add to your AI — have it check for missing accessibility features. My AI has called me out on this a couple times, and my only response was “Oh yeah, that’s a good idea.”

Final Thoughts

AI has a wide range of tools that can make a senior developer’s process more efficient and their code cleaner and more polished. It allows us to spend less time doing boilerplate and setup and more time fine-tuning and making cleaner, more robust architectures.

If there’s one major takeaway from this discussion, I would say it like this: AI is a new suite of tools for engineers, not a replacement for them. Everything an AI can generate requires someone with genuine knowledge, expertise, and understanding of the requirements, the broader context, the target audience, etc. to bring the project home.

Never be afraid of using the newest, greatest tools. Anyone who rejects AI tools outright is very likely to fall behind at this point; but on the other hand, anyone who thinks AI is a replacement for an engineer who can provide the informed analysis on the project will find themselves tying their own hands.

Apple just did something wildly out of character.

On February 3, the company that rehearses Keynotes for months and guards product secrets like nuclear codes just … dropped a beta. No event. No Tim Cook. No “one more thing.” Just a surprise Xcode 26.3 release with features that weren’t even on the roadmap, complete with tutorials and an open invitation to try it now.

What’s inside? AI agents that can actually control Xcode.

Not “suggest the next line” AI. Not “autocomplete on steroids” AI. We’re talking AI that reads your entire project, understands your architecture, refactors dozens of files simultaneously, fixes bugs, writes tests, and interprets compiler errors — while you’re in a meeting.

You know that moment in sci-fi movies where someone says “Computer, fix the hyperdrive” and it just … does? We’re there. Except it’s “Claude, add Dark Mode support” — and your iOS app suddenly has Dark Mode.

Three weeks ago, this was science fiction. Today, it’s a beta download. Let’s talk about what just changed.

What is MCP?

Model Context Protocol (MCP) is an open standard created by Anthropic that allows AI models to securely connect to external tools, data sources, and applications. Think of it as a universal adapter that lets AI assistants like Claude interact with your development environment in a structured, safe way.

Instead of you copying and pasting code suggestions from a chat interface, MCP lets the AI actually interact with Xcode — reading your project files, understanding your app’s structure, running builds, and even making changes directly. It’s like having a knowledgeable pair programmer who can actually touch the keyboard.

MCP offers a powerful, standardized protocol for tool integration, surpassing traditional IDE plugins. Its client-server architecture, with Xcode as the MCP host and AI agents as clients with specific permissions, enables context-aware assistance that factors in your entire codebase, not just the open file.

MCP empowers AI to become a true development teammate, not just a code suggestion tool. Its standardization ensures consistent AI-assisted development across tools and continuous improvement as the ecosystem matures.

With Xcode supporting MCP, you don’t have to copy and paste code between the chat and your files; instead, the AI agent can take control of Xcode using data and context providers Apple has included.

What is Agentic AI?

Agentic AI refers to AI systems that can take autonomous action to complete tasks, rather than just responding to single prompts. An agentic AI can plan multistep workflows, use tools, make decisions, and iterate on solutions without constant human guidance.

Traditional AI code assistants are like having someone suggest the next line of code. Agentic AI is like delegating an entire feature implementation. You might say “Add dark mode support to this app,” and the agent will analyze your code, identify all the files that need changes, make those changes, test them, and fix any issues it finds — all with minimal supervision.

Agentic systems use reasoning and planning capabilities to break down complex tasks into subtasks, execute them using available tools (through MCP), evaluate results, and adjust their approach. In Xcode 26.3, this means the AI can navigate your project structure, analyze dependencies, run the compiler, interpret errors, search documentation, and iteratively refine its solutions. It’s particularly powerful for refactoring, fixing bugs that span multiple files, and implementing features that require coordinated changes across your codebase.

This represents a force multiplier for development teams. Rather than speeding up individual coding tasks by 20-30%, it can potentially handle entire features autonomously, allowing senior developers to focus on architecture and complex problem-solving while the AI handles implementation details. This could dramatically compress development timelines for certain types of work.

How Do I Set Them Up?

The first step is getting Xcode 26.3. As of the publication of this article, Xcode 26.3 has now been released publicly and is available from the Apple Developer Downloads (https://developer.apple.com/download/all/?q=Xcode) website or the Mac App Store (https://apps.apple.com/us/app/xcode/id497799835?mt=12).

When you launch Xcode 26.3 for the first time, you’ll get the dialog above, giving you some information about the release and a video link to see more details (https://developer.apple.com/videos/play/tech-talks/111428).

To get started with agentic AI development, go to Settings (Command+,), select Intelligence, then choose either the OpenAI or Anthropic provider. Click “Get” to download the models for interacting with Xcode for your provider. Next, you’ll need to authenticate with your provider.

You need a paid account with either OpenAI Codex or Anthropic Claude to use them with Xcode. If you have a subscription plan, it’ll utilize the usage available in your subscription first, then any API access you have allowed for your account.

Once you’re signed in, you can also select the models that should be used for Xcode, if supported. For Anthropic, you can select between Opus, Opus + Sonnet, or just Sonnet. Opus is the highest reasoning model from Anthropic while Sonnet can give you a better cost to reasoning approach for smaller tasks that don’t require as much reasoning about the situation.

When you’re ready to begin, toggle the Coding Assistant by clicking the Intelligence icon in the left pane or by pressing Command+0.

The Coding Assistant has a message box at the bottom where you type your prompt and an attachment button that lets you attach an image for mockups or other visual aids that can help the model process your request. Type in a prompt, and it’ll jump into action. Thanks to the MCP integration with Xcode, Claude and Codex can really shine, interacting with the Xcode project fully: creating new files, refactoring efficiently, even making provisioning changes without you lifting a finger.

The best part is that you get rich in-line previews of code and SwiftUI previews — plus the app automatically builds itself, checks for errors, then fixes those errors, ensuring that when the agent is done, the app builds cleanly and is ready for manual or automated testing.

We really like the way Apple has integrated the Coding Assistant into Xcode and can’t wait to see what is next for Xcode and MCP integration. We think the best way to experience this is just to write prompts with it. So let’s take a look at how you can get started in your own iOS projects.

Writing Your First Prompt

The key to effective agentic AI development is learning to delegate tasks rather than micromanaging code generation.

Starter Prompts for Beginners

Start with contained, well-defined tasks:

“Add a new SwiftUI view called SettingsView with toggles for Dark Mode, notifications, and haptic feedback. Use the same styling as ProfileView.”

This gives the agent clear constraints and a reference point. The agent will:

• Create the new file in the appropriate location
• Implement the UI with proper SwiftUI patterns
• Match the styling you specified
• Update your navigation to include the new view, if needed

“Fix the memory leak in ContentView. The images aren’t being released when the view disappears.”

The agent will analyze your code, identify the leak source, and propose a fix.

Intermediate Prompts for Experienced Developers

Once you’re comfortable with the starter, you can delegate more complex work:

“Refactor the networking layer to use async/await instead of completion handlers. Maintain the existing error handling behavior and update all call sites.”

This is a tedious but straightforward refactoring that touches many files — perfect for an agent.

“The app is crashing when users rotate the device on the detail screen. Debug this and implement a proper solution.”

The agent will run the app in the simulator, reproduce the crash, analyze the stack trace, and implement a fix.

Advanced Prompts for Senior Developers

“Implement offline support for the entire app. Cache all API responses locally, sync changes when connectivity returns, and handle conflict resolution using last-write-wins strategy. Update the UI to show sync status.”

This is a multiday feature that the agent can break down into subtasks: setting up Core Data or SwiftData, implementing the sync engine, modifying all network calls, adding UI indicators, and testing various offline/online scenarios.

“Our test coverage is at 45%. Analyze the codebase and write unit tests for all ViewModels and service classes, aiming for 80% coverage. Focus on edge cases and error handling.”

The agent will examine your code, identify untested paths, and generate comprehensive test suites.

Best Practices

• Be specific about constraints: Clear directions like “Use SwiftUI, not UIKit” or “Don’t modify the existing database schema” help the agent stay aligned with your architecture.
• Reference existing patterns: Pointing to a file by name, like “Follow the same pattern as UserViewController,” tells the agent to maintain consistency.
• Iterate in conversation: If the first result isn’t quite right, you can refine, such as: “That works, but use Combine instead of async/await for consistency with the rest of the app.”
• Review everything: Agentic AI is powerful but not infallible. Always review changes before committing, especially for production code. Remember that you are the developer in charge, use the AI to your advantage and always feel free to prompt the AI in the same way you would a junior developer: If you want something done a specific way, be sure to tell it.
• Start small, scale up: Begin with low-risk tasks (like writing tests or documentation) before delegating critical features.

What This Means for iOS Development

For individual developers, Xcode 26.3’s agentic capabilities can eliminate much of the tedious work that slows down development — boilerplate code, refactoring, test writing, and bug hunting. This frees you to focus on what humans do best: creative problem-solving, user experience design, and architectural decisions.

For teams and organizations, this technology could significantly compress development timelines for certain types of projects, particularly those with well-defined requirements and established patterns. However, it also raises important questions about code review processes, testing strategies, and how to effectively manage AI-generated code at scale.

The real power of Xcode 26.3 isn’t that it makes AI write code faster — it’s that it makes AI a collaborative partner that can analyze your entire project context and can take meaningful action. Whether you’re a solo developer building your first app or a CTO managing a large iOS team, the agentic development paradigm is worth exploring.

You’ve probably heard the buzz phrase “vibe coding,” but do you know what it means — or whether you should be jumping on the bandwagon? In this article, I’ll introduce you to the pros and cons of this way of developing code and talk about how you can get started with it.

At MartianCraft, we focus on building iOS apps in Xcode, so the models and tools I’ll discuss will be specific to that — but the overall ideas apply to any kind of development.

So, what is vibe coding?

The term “vibe coding” was coined in February 2025 when Andrej Karpathy posted about using AI tools like Cursor and “fully giving into the vibes” — forgetting code even exists while developing through conversation with an LLM.

The idea of vibe coding grew and gained momentum throughout 2025 as LLMs improved, making it easier for people to use them to create code. But the development community continues to have mixed feelings about vibe coding, with some viewing it as a tool that improves productivity and others believing that it makes people worse developers.

Before AI, developers spent a lot of time and energy not only writing code (including boilerplate code) but also researching, viewing code from other projects, correcting false starts, and so on. The promise of AI is that you don’t need to do that anymore: You can just ask the model to generate the code you’re looking for, whether it’s boilerplate or, in some cases, a full-blown app. You can also use it as a coding assistant that can debug and answer questions about your code. But does the reality live up to the promise?

At MartianCraft, we consider vibe coding to be one more tool in our toolbox — and as with any tool, it’s important to understand its strengths and limitations. Let’s start with the basics of LLMs.

Large language models

LLMs, or large language models, are a type of AI that can recognize text, images, videos, and more, based on specific training. The most common form of LLM is the one you’ve likely come across that responds to text (and now image) prompts through a chat-based interface, like ChatGPT or Claude.

One of the things that make LLMs so powerful is that they can be trained: You can teach a model to become an expert in a specific area. For example, on OpenAI’s GPT Store you’ll see models that focus on a variety of niches, including one that focuses on SwiftUI.

However, LLMs definitely have some limitations and restrictions. Here are some of their most basic limitations:

• LLMs are not human, no matter how conversational their replies are. Don’t expect them to comprehend beliefs or emotions, or to think like a real person.
• LLMs are almost always confident about their answers, but those answers are sometimes completely wrong (so-called hallucinations). You always need to double-check what they have to say.
• LLMs have no built-in real-time knowledge. In fact, every LLM has a cutoff for its knowledge base — for example, the cutoff for ChatGPT 5.1 is mid-2024. So if you ask ChatGPT about breaking news or, say, when iPhone 17 was released, it can only answer by scraping the web for current information. If you were to turn off web scraping, it couldn’t tell you when iPhone 17 came out.
• LLMs also have limited long-term memory. When you interact with them, they only store tiny bits of information from the conversation, not every detail. If you want to reference something from a conversation several days earlier, you will more than likely have to re-enter the information you discussed.

So LLMs are very powerful, but you have to watch for hallucinations and outdated information, which they will present with total confidence.

LLMs and coding

For coding, this means you have to be extra careful when you’re dealing with relatively recent APIs. Let’s say you want to integrate Liquid Glass into your SwiftUI app. Liquid Glass was introduced in 2025, so it’s not part of ChatGPT’s knowledge base. If you ask ChatGPT, it will more than likely provide you with code it found on the internet — which might be fine — but its knowledge limit means that it won’t incorporate the best practices in Apple’s developer documentation.

On the other hand, using an LLM to build code — vibe coding — takes advantage of a trained AI’s strengths in pattern matching and consistency. It can be a helpful tool for a variety of development roles.

Designers

Vibe coding can be a great tool for designers who don’t know how to code to start learning, whether they want to expand their skills as a dev team member or to build hobby products that they’ve designed for themselves. And although designers who do have experience coding are more rare, they can also use vibe coding to their advantage — in fact, they probably have the highest potential of building a successful product through vibe coding. This type of designer understands user experience and user interface design, and they can bring those designs to life via code thanks to AI.

Beginning developers

Vibe coding is a great way to learn how to code. You can ask the model to build a feature and then ask it to break the code down. You can also ask the model questions, like “I want to integrate Core Data into my app, can you lay out the instructions on how to do that?” The model will break down how to add Core Data, including the entities, attributes, and relationships you need. Then, you can ask the model to generate the code to fully integrate Core Data in your app. And if you get stuck, the AI is there to help. This can be a great way for beginning developers to get experience with complex tasks.

One caveat, though, is that AI-generated code should never go into a production codebase until it has been reviewed by an experienced developer who understands app architecture, security issues, and the other important factors that go into creating user-ready apps.

By the way, if you’re learning to code you can also copy open source code into an LLM and ask it to explain the code for you. That may not fall under the category of “vibe coding,” since you’re not generating code, but it’s a great way to use the tool to increase your coding knowledge and skills.

Mid- to senior-level developers

If you have some experience with development, you’re in a great position to really put vibe coding to work for you. Experienced devs can use AI to generate template code for specific features that they can then iterate to their liking, so they don’t have to start coding that feature from scratch. They can also use it to help clean up their code, fix bugs, simplify over-complex logic, modernize code (such as converting UIKit code to SwiftUI), build more complex user interfaces, and more.

As a mid- to senior-level developer, you likely spend time waiting for more novice devs to complete redundant or tedious tasks. Working with an LLM can allow you to generate and review code in a fraction of the time. And having knowledge and experience means that you can carefully review the AI output to catch errors and steer the LLM to produce results that work for you.

Which brings us to the topic of prompts.

The art of vibe prompting

Prompts are at the core of being an effective vibe coder. A prompt is simply the instruction given to the AI model, but the way it’s phrased determines the quality of the response you get back from the model. Well-structured prompts are detailed enough to guide and give the model a direction. With the right prompt, you can build anything. Let’s look at some examples of stronger and weaker prompts.

Here’s an example of a weak prompt: “Build a to-do list app in SwiftUI.”

This prompt is much too vague and doesn’t give the model any kind of solid direction. It doesn’t define any features or specify any additional tech stacks. There are no UX or UI expectations. A prompt like this can cause the model to make a lot of assumptions, which can lead to results that are not what you had in mind.

A better prompt would look something like this: “Build an iOS to-do list app using SwiftUI and SwiftData for iOS 17+. App requirements are: the ability to add, delete, and mark a task completed. The app will need to persist data locally using SwiftData. I want the project to follow the MVVM style, and it also must support light and dark appearances. Use a clean, Apple-style UI.”

This prompt provides the model with a clear tech stack, feature scope, UI and UX directions, and information on how to organize the files. It’s much more likely to produce the results you’re looking for, especially with a few rounds of iteration.

While it’s important to give the model enough information to work with, you also need to make sure that the information you provide is clear and actionable. Here’s an example of an overcomplicated prompt:

“Build an iOS to-do list app using SwiftUI or UIKit. I prefer SwiftUI, but if you think UIKit is better, use that. Use MVVM or something similar, but not too rigid. The UI should be minimal and also customizable, modern but timeless, and mainly optimized for power users and beginners. Should also support 15+ but must use the new APIs where possible. Can you include analytics, notifications, background tasks, and any type of accessibility options too? The app also needs to be able to scale to millions of users, but it needs to be simple. Don’t over-engineer it, but make sure it’s production ready.”

A prompt like this is unlikely to produce good results (or maybe any results). There’s no clear direction: The requests are all over the place, and some of them are confusing, like “The UI should be minimal and also customizable.” Customizable how? It would be better to provide an example of how the UI can be customized to help direct the model. Also, asking the model to decide the best approach means that it has to first come up with a solution, and then compare that solution to other solutions to make sure it’s truly the best one. All the while, it has to factor in completing all the tasks in the prompt — it will end up getting overwhelmed, and the response will suffer.

Learning to write prompts with the right balance of detail and conciseness takes a bit of trial and error, but the good news is that you can see the results quickly and adapt your approach until you’re getting the results you’re looking for.

AI models and tools

For those who are ready to start integrating AI into their workflow, what’s the best way to do that?

First, it’s important to understand the difference between AI models and AI tools. Models are the underlying LLMs, such as GPT-5, Claude, and Llama. Each model has unique training data preferences, token limits (more on tokens in a moment), and performance characteristics.

Tools, on the other hand, are applications or platforms — like Cursor, AlexCodes, or Xcode’s predictive code completion — that make these models available for developers to use. Some tools offer access to multiple models: AlexCodes, for example, gives you the freedom to select which model you want to use on the fly. This can be good for when you’re building different types of apps and you want to rely on the strengths of different models for different tasks.

Next, you need to understand the role of tokens for AI users, both as an individual and for enterprises. A token is basically the unit of thinking for AI. It’s a unit of data — like a word, a piece of punctuation, or even a part of a word — that the model breaks text down into in order to process and generate language. For comparison, you can think of tokens for AI as being like pixels in images or frames in videos. There are two types of tokens: input tokens, which are generated from your prompt and sent to the model, and output tokens, which the model sends back in response to your prompt.

Why does this matter to you as a user? Because, unfortunately, you have to pay for them. Tools offer a certain number of free tokens, but beyond that, any time tokens are being generated, you’re getting charged.

For example, as an individual using OpenAI’s ChatGPT app on the free plan, you are likely to quickly hit your account token limit. At that point, you will have to upgrade your account to use more tokens. But even as a paying user you can still hit token limits, depending on how long the conversation is, how long your prompts are, and the tasks in your prompts. You’ll receive an alert as you get closer to your limit, and in this case it’s suggested that you start a new conversation with the model so the model can continue to perform at its best.

For an enterprise with an AI chat feature in your app, your monthly usage bill is determined by the amount of tokens being generated in your app. You’ll also be charged for all the API calls made. As you can imagine, as your user base scales up, AI can get costly: More users equals more tokens. More tokens equals rising cloud bills, unpredictable costs, and pressure to figure out ways to optimize prompts to reduce cost.

So tokens can be a headache, whether you’re an individual consumer or an enterprise. As a consumer, determining the right plan for you depends on how much you’re going to be using the tool. On the enterprise side, it’s all about monitoring costs and figuring out ways to reduce them.

Below are some comparisons of popular AI models and AI tools you can use with Xcode to build iOS apps.

Comparing popular models

Comparing popular AI tools for Xcode

Final thoughts

Lastly, there are a few important things to keep in mind when you’re vibe coding. They boil down to this: Vibe coding isn’t a substitute for development knowledge.

It’s a great way to learn by seeing code generated for you, but most AI-generated code is outdated — or worse. Until AI model imitations truly become limitless, I wouldn’t trust it to build an entire app on its own.

Vibe coding can lead to real issues later down the line for your app, especially around scalability and security. AI-generated code can be more complex than it needs to be, and it can include inefficient logic that can cause bugs, performance problems, or even vulnerability as your app’s user base grows.

In short, vibe coding should be used as a tool, not a replacement for the human work of development. Understanding how to code is essential for getting the most out of vibe coding. For iOS development, Apple’s Swift documentation is a great place to start.

As we step into 2026, the landscape of iOS development is undergoing one of its most significant transformations in over a decade. At MartianCraft, we’ve spent years at the forefront of Apple platform development, and the convergence of technologies we’re witnessing today feels genuinely unprecedented. From Apple’s bold new design language to the democratization of on-device AI, from revolutionary improvements to Swift’s concurrency model to the maturation of spatial computing — this is a pivotal moment for anyone building applications in the Apple ecosystem.

This article explores the key technological advancements and emerging trends that have captured our attention, imagination, wants, and desires. Whether you’re a C-level executive evaluating technology investments, a product leader planning your roadmap, or a fellow developer eager to understand what’s coming, we hope this serves as both a practical guide and an invitation to share our excitement about what lies ahead.

Apple Intelligence

Last year, Apple worked to add Apple Intelligence throughout iOS 26, even going as far as opening up their on-device models to third-party developers through Foundation Models. This was a game-changer for so many applications, which can now implement artificial intelligence without relying on costly APIs and usage from Anthropic, Google, or OpenAI.

This opened the flood gates for apps to offer better AI solutions to end users, but many developers found these models to still be lacking. Some of the chief complaints with the local Foundation Models have been that it’s slow and that it can’t process the amount of data that you can do with specialized services.

Apple has solved these local Foundation Model challenges with their Private Cloud Compute system. This system was developed to integrate with Apple’s own LLM servers or partner APIs to process larger tasks that require more power — securely and without exposing user data. Of course, the local models were made available to developers, but the Private Cloud Compute integration is exclusive to Apple’s first-party apps, including the Shortcuts app.

We’re excited to see the work that Apple has done over the past year with the local models and their PCC models. We’re also hoping that Apple opens up their PCC models so that third-party developers can integrate with them with an API, even if it means that Apple charges for usage like they do with WeatherKit and other developer APIs and tools.

Siri

Siri was supposed to receive a major overhaul in iOS 26, but it seems that Apple has yet to deliver on that feature. Most recently we’ve seen that Apple is planning on partnering with Google to integrate their Gemini AI platform with Siri to process requests and beef up the reliability of the virtual assistant that has been on our iPhones since iPhone 4S.

As we look forward to this year, we’re hoping to see Apple deliver on this promise and actually make Siri improvements that show notable impacts to users and developers alike.

App Intents and the Promise of Real Integration

The evolution of App Intents represents one of the most significant opportunities for third-party developers to finally make their apps first-class citizens in the Siri ecosystem. With the App Intents framework, Apple provided the foundation for apps to expose their functionality in ways that Siri can understand and execute — but the developer experience and user discoverability remain challenging.

What we’re hoping to see this year is a more intelligent Siri that can actually reason about the intents our apps expose. Currently, users need to know the exact phrase or shortcut name to trigger many app-specific actions. With the integration of more capable language models, Siri should be able to understand natural variations and contextual requests. If a user says “show me my recent transactions” in a banking app, Siri should be smart enough to map that to the appropriate App Intent without requiring the user to memorize specific trigger phrases.

We’d also like to see improvements in how Siri handles multistep workflows that span multiple apps. The Shortcuts app has shown us what’s possible, but these workflows shouldn’t require manual setup for common tasks. Imagine Siri understanding “I’m heading to the gym” and automatically updating your workout app, adjusting your smart home settings, and queueing up your exercise playlist — all through intelligently chained App Intents.

Perhaps most importantly, we need better debugging and testing tools for App Intents. Currently, developers are working somewhat in the dark, unsure of how Siri will interpret their intents in practice. Apple could dramatically improve the developer experience with better Xcode integration, simulation tools, and analytics showing how users are actually trying to invoke our app’s functionality through Siri.

Liquid Glass Improvements

Liquid Glass was Apple’s biggest design changeover in iOS since iOS 7. It’s a very divisive design change: There are folks who absolutely love the design, and there are people who absolutely hate the design. Love it or hate it, we’re looking forward to stability with the new design in the same way we saw improvements to and stability in the iOS 7 redesign inside iOS 8.

The iPad Challenge

The iPad implementation of Liquid Glass has been particularly contentious, and for good reason. The larger canvas of the iPad exposes many of the design system’s growing pains in ways that the iPhone manages to hide. The translucent, flowing aesthetic that feels premium and spatial on a 6.1-inch screen can feel overwhelming and disorienting on a 12.9-inch display.

One of the primary challenges is information density. The iPad has always been about productivity and multitasking, but Liquid Glass’s generous spacing and emphasis on negative space often feels at odds with these goals. Many productivity-focused apps have reported that their iPad interfaces now show significantly less content per screen, forcing users to scroll more frequently. The beautiful glassmorphic cards and panels that define the design language consume substantial screen real estate, and on the iPad, this feels like a particularly wasteful trade-off.

The multitasking experience presents another set of complications. Split View and Stage Manager were already complex features to design for, but with Liquid Glass’s translucent layers and dynamic blurring effects, maintaining visual hierarchy and ensuring that interactive elements are clearly distinguished has become significantly more difficult. When two apps with Liquid Glass interfaces are side by side, the layered translucency can create a visual soup where it’s unclear which controls belong to which app.

We’re hoping that iOS 26 dot releases and iOS 27 and beyond will bring refinements specifically tailored to the iPad’s unique needs. This might mean more aggressive information density options, clearer visual separation in multitasking scenarios, or even context-aware adjustments to the Liquid Glass effects based on what the user is doing. Apple has historically been thoughtful about these kinds of platform-specific considerations, and we’re optimistic that they’ll continue to iterate on the iPad experience throughout the year.

We’d also like to see Apple provide better tools and guidelines for developers navigating these challenges. The current design resources don’t adequately address how to balance the aesthetic goals of Liquid Glass with the practical needs of information-dense applications. More comprehensive design patterns for tables, lists, and data-heavy interfaces would be invaluable.

Claude Code and Other LLM Agents

Over the past two years, LLMs have changed the way that we do development for iOS applications. There’s still a lot of improvement to go, but the landscape is changing right before our eyes.

The Swift and SwiftUI Gap

The promise of AI-assisted development has been tantalizing, but the reality for iOS developers has been more complicated than for our colleagues in web development or backend engineering. The fundamental challenge is that Swift and SwiftUI are relatively niche languages in the grand scheme of LLM training data. While there are millions of JavaScript and Python repositories to learn from, the corpus of Swift code — particularly modern SwiftUI — is substantially smaller.

This manifests in practical ways that slow us down daily. LLMs often suggest outdated patterns from the UIKit era when we’re working in SwiftUI. They hallucinate modifiers that don’t exist or combine them in ways that won’t compile. They’re particularly weak with Swift’s more advanced features, like result builders, property wrappers, and the newer concurrency model with async/await and actors. When working with cutting-edge APIs from the latest iOS releases, we frequently find ourselves correcting the model more than being assisted by it.

The challenges extend beyond code generation. iOS development has unique tooling, build systems, and deployment requirements that LLMs struggle to navigate. Xcode project configurations, build settings, provisioning profiles, and the intricacies of App Store submission are all areas where current AI assistants provide limited value.

A Changing Landscape

That said, we’re genuinely excited about the trajectory we’re seeing. Tools like Claude Code, GitHub Copilot, and cursor.ai are rapidly improving their understanding of Swift and SwiftUI patterns. We’re starting to see models that can handle more complex refactoring tasks, suggest appropriate architectural patterns for SwiftUI apps, and even help navigate the transition to Swift 6’s strict concurrency checking.

What’s particularly promising is the emergence of agentic coding assistants that can work more autonomously. Rather than just providing code snippets, these tools can understand broader project context, make cross-file changes, run tests, and iterate on their own output. For iOS development, this means an assistant that can update a view model, modify the corresponding SwiftUI view, adjust the navigation flow, and ensure everything still compiles — all from a natural language prompt describing what you’re trying to accomplish.

We’re also seeing interesting developments in multimodal LLMs that can understand design mockups and generate corresponding SwiftUI layouts. While the results aren’t production ready yet, the ability to go from a Figma design to a rough SwiftUI implementation in minutes rather than hours could fundamentally change how we approach prototyping and iteration.

Looking ahead to 2026, we’re optimistic that the combination of larger training datasets (as more developers adopt Swift and SwiftUI), more sophisticated models, and better integration with Apple’s development tools will narrow the gap between the AI-assisted experience in iOS development and other platforms. We’re particularly hopeful that Apple will embrace this trend and provide official APIs or tooling that help LLMs understand Xcode projects, access documentation more intelligently, and perhaps even integrate with the compiler to provide better error correction and suggestions.

The key is maintaining realistic expectations. LLM assistants are tools that augment our capabilities, not replacements for deep iOS development expertise. The developers who will thrive in 2026 are those who can effectively collaborate with these AI tools while bringing irreplaceable human judgment about architecture, user experience, and the subtle nuances that make iOS apps feel truly native and polished.

What are you most excited about in iOS development this year? We’d love to hear your perspective, continue the conversation, and build apps alongside your team. Reach out by contacting us here.

The annual list celebrates the nation’s top B2B organizations with a proven history of empowering entrepreneurs and driving business growth.

San Francisco, CA, November 5, 2025 – Inc., the essential media playbook for the entrepreneurs and leaders defining our future, unveiled its fourth annual Power Partner Awards recognizing B2B companies nationwide that have demonstrated an unwavering commitment to supporting startups and helping established businesses scale. MartianCraft is proud to be featured among the select group of firms recognized for excellence in software development, infrastructure, and technical innovation.

The Inc. Power Partner list is compiled based on rigorous feedback from the people who know these companies best: their clients. Every honoree received high marks for being a vital catalyst in helping leadership teams navigate the complexities of the modern business landscape. By managing critical functions—from sophisticated mobile architecture and cloud migration to digital transformation—these partners allow founders to stay laser-focused on their primary mission.

“This is our definitive guide to the vendors and suppliers who go above and beyond for small- and midsize customers,” said Inc. editor in chief Mike Hofman. “Our vetting process involves deep research into products, services, and reputation, underpinned by direct testimonials from founders who have seen the results firsthand. We are thrilled to highlight these genuine, mutually beneficial partnerships.” “Receiving this honor for another year is a profound reflection of our team’s consistency and passion,” said Kyle Richter, CEO and co-founder of MartianCraft. “At MartianCraft, we don’t just build apps; we build long-term trust. This award belongs to our developers and designers and the visionary partners who challenge us to push the boundaries of what’s possible in mobile technology every day.”

Having recently surpassed two decades of innovation, MartianCraft continues to bridge the gap between ambitious ideas and technical reality. While we are proud of our legacy—which includes developing the first multiplayer iPhone game and pioneering digital publishing—we remain focused on the future. In 2025, we continued to lead the way in creating high-impact mobile solutions that solve real-world problems for Fortune 100 giants and burgeoning startups alike. Our ability to integrate seamlessly with internal teams and deliver polished, scalable code remains the cornerstone of why businesses choose us as their long-term technical partner.

To view the complete list of 2025 award winners, go to: https://www.inc.com/victoria-salves/meet-the-2025-power-partners-in-technology-development/91240338 The November 2025 issue of Inc. magazine is available online now at https://www.inc.com/magazine and will be on newsstands beginning October 28, 2025.

About MartianCraft

MartianCraft is a premier mobile software design and development agency. We specialize in solving complex technical challenges, from refining enterprise-grade software to launching disruptive new ventures. Our expertise spans native iOS, Android, Mac, and robust backend development. With over 1,000 apps shipped for a diverse range of clients, we combine twenty years of experience with a forward-looking approach to mobile craftsmanship.

About Inc.

Inc. is the leading media brand for the risk-takers and innovators shaping the future of business. Through world-class journalism and prestigious recognitions like the Inc. 5000 and Power Partners, Inc. provides entrepreneurs with the tools and community they need to succeed. With a brand footprint of over 40 million, Inc. continues to be the most trusted resource for those driving the global economy. For more information, visit www.inc.com.