NativeFirst NativeFirst
All posts

Posts tagged with: SwiftUI

51 posts found

All Development AI Apple Vibe Coding SwiftUI Announcements
A building permanently wrapped in construction scaffolding
SwiftUI iOS Development

SwiftUI Just Turned Seven. Hacker News Is Having the Itch.

SwiftUI shipped in 2019 and just hit its seven-year mark, and a viral Hacker News thread (plus pieces from Yakov Manshin and John Gruber) is relitigating whether it ever grew up. I've built a real app in it for months — here's where my own bugs match the complaints, and where they don't.

7 min read
An organized box of wrenches and hand tools, each one distinct but sharing the same case — a Swift toolbox metaphor
Foundation Models Swift

Apple Just Open-Sourced the 'Skills API' Everyone Assumed Was a Claude Thing

Apple's new foundation-models-utilities package brings a Skills API, history compaction, and a chat-completions bridge to Swift's Foundation Models framework. Here's what's actually in the box, and how it maps onto BrewLog.

7 min read
A compact multi-port GAN charging adapter — one small brick, several different outputs, which is exactly the pitch behind a library that puts several AI backends behind one Swift interface.
Swift SwiftUI

I Tried the Library That Puts Foundation Models, OpenAI, and MLX Behind One Swift API

SwiftAI is a new open-source Swift package that wraps Apple's on-device Foundation Models, OpenAI, and MLX behind one interface — reply(to:), @Generable structs, streaming, tool calls. I actually installed it, ran real on-device inference, and hit a documentation bug and a guardrail glitch within ten minutes. Here's what works, what doesn't, and whether it's worth adopting today.

8 min read
A wall completely covered in handwritten post-it notes — the external memory an AI coding agent needs because it can't hold your whole codebase in its head.
AI Coding Context Engineering

Your AI Agent Has Amnesia: Context Rot Is Why It Forgets Your Swift Codebase by Lunch

Context rot is the reason your coding agent starts brilliant and turns into a confidently-wrong intern two hours later. Chroma's study measured it across 18 models, it hits SwiftUI codebases hard, and the fix isn't a bigger context window — it's context engineering. Here's what actually works in Xcode 26.

9 min read
A vintage black typewriter and a modern MacBook sitting side by side on a wooden desk, shot from directly above — the old tool and the new one, both still doing real work.
Swift UIKit

UIKit Tricks SwiftUI Still Can't Do (Yet): Back to UIViewRepresentable

Day 28 of the 30-day iOS series. SwiftUI has no PDF viewer, no custom keyboard primitive, and no waterfall grid — five real gaps where you still reach for UIViewRepresentable, anchored by a real PDFKit-backed brew history export built TDD-first for BrewLog.

10 min read
An espresso machine portafilter pouring two separate streams of coffee into two paper cups sitting side by side on a stainless steel drip tray — one source, two independent streams.
Swift Combine

Combine in 2026: The Three Cases Where It's Still Better Than async/await

Day 27 of the 30-day iOS series. A real searchable brew history for BrewLog, built with Combine instead of async/await, and the three reasons it was the right call: debounce, independent multiple subscribers, and a four-way CombineLatest pipeline.

10 min read
A hand squeezing the last drips of coffee from a paper filter into a Chemex — the kind of multi-minute brew that's worth glancing at from the Lock Screen instead of standing over.
Swift ActivityKit

Live Activities and the Dynamic Island: A Decision Matrix, Not a Demo

Day 26 of the 30-day iOS series. A real ActivityKit countdown for BrewLog's pour-over timer, the one-function decision matrix that decides which brew methods even get one, and the exact reason it still won't show up on a Lock Screen.

10 min read
Close-up of an espresso machine's row of glowing buttons — press one, skip the rest of the ceremony, which is the entire pitch of an App Intent.
Swift WidgetKit

WidgetKit and App Intents: Logging a Brew Without Opening the App

Day 25 of the 30-day iOS series. A real App Intent that logs a brew from Spotlight or a widget button, the @Dependency crash that nearly cost me an evening, and the honest line between what's tested and what's still a mechanical Xcode step.

9 min read
A red traffic light glowing above an unlit green light on a city street — the stop-then-go cycle that gives test-driven development its name.
Swift TDD

TDD for SwiftUI: A Red-Green-Refactor Workflow That Isn't Academic

Day 21 of the 30-day iOS series. I went looking for a BrewLog feature to drive test-first and found a real bug already shipped: the Streak stat has been hardcoded to zero since day one. Here's the actual red-green-refactor session that fixed it.

10 min read
Colorful electrical wires and cables neatly arranged — red, yellow, blue, and green — representing connections and dependencies.
Swift Dependency Injection

Dependency Injection in Swift Without a Framework

Day 19 of the 30-day iOS series. Protocol-based DI, @Environment as a SwiftUI-native container, and the factory pattern — all without Resolver, Swinject, or any third-party glue. Includes a TDD example that shows why DI and testability are the same conversation.

11 min read
A coir doormat reading 'well, hello there.' on a red brick step in front of a blue door with red trim.
StoreKit 2 Swift

StoreKit 2, Part 2: Free Trials, Win-Back Offers, and Promo Codes That Actually Convert

Day 16 of the 30-day iOS series. I add a 7-day free trial, a win-back banner for lapsed subscribers, and offer-code redemption to BrewLog's paywall — concrete App Store Connect configuration plus the Swift code, all covered by Swift Testing.

17 min read
A heavy brass padlock fastened through the latch of a teal metal door.
StoreKit 2 Swift

A StoreKit 2 Paywall From Scratch: Subscriptions, a Transaction Listener, and a Restore Button That Works

Day 15 of the 30-day iOS series, first of a three-part run on monetization. I built BrewLog's real paywall with StoreKit 2 — two subscription products, a transaction listener, and a restore flow — with zero third-party SDKs. Every number the paywall shows comes from one pure, tested function.

13 min read
A stack of labeled cardboard moving boxes and houseplants against a wall, mid-move.
SwiftData Core Data

SwiftData Two Years Later: What's Solid, What Still Bites, and the Migration Test You're Not Writing

Day 14 of the 30-day iOS series. SwiftData is about two years old now, and the honest verdict is mixed. I already wrote the long field report on where it broke in production — this post is the part that report didn't have room for: a VersionedSchema + SchemaMigrationPlan test that proves a schema change is safe BEFORE TestFlight finds out for you.

12 min read
A laptop screen showing a dark-mode analytics dashboard with line and bar charts tracking load time, bounce rate, and session metrics.
Swift SwiftUI

@Observable vs ObservableObject: What 1,000 Rows and a Redraw Counter Actually Showed Me

Day 13 of the 30-day iOS series. I built a redraw counter into BrewLog, put 1,000 rows in two identical lists side by side — one backed by @Observable, one by ObservableObject — and toggled a single favorite ten times. The row counts tied 10-10. The list counts didn't. Here's the real number, and exactly where it comes from.

13 min read
A flat lay of overlapping vintage paper maps at different scales — local town plans layered under a wider regional survey of the Isle of Wight.
Swift SwiftUI

@State, @Bindable, @Environment: The Complete Map for @Observable (and the Question You're Actually Asking)

Day 12 of the 30-day iOS series. With @Observable, SwiftUI lets you slap @State, @Bindable, @Environment, or a plain let on the same class — and compiles all of them. Here's the question that actually decides which one is correct, one map that resolves 95% of the confusion, and three real BrewLog bugs (one silent, one a compile error, one a runtime crash) that come from picking wrong.

11 min read
A person leaning into a coin-operated lookout telescope, observing a savanna in the distance — you keep feeding the machine to keep watching.
Swift SwiftUI

ObservableObject → @Observable: The Migration Guide That Skips the Marketing (and the Autoclosure Gotcha Apple Forgot to Mention)

Day 11 of the 30-day iOS series. Apple's migration guide makes ObservableObject → @Observable look like a find-and-replace. It mostly is — except for one quiet behavioral change: @StateObject only ran your initializer once, and @State runs it on every render. Here's the multiple-init bug that causes, why it's worst in exactly the init you were proud of, and how to fix it with a test that turns 'no side effects in init' into a hard, green invariant.

12 min read
A workbench with tools organized and ready to use — the State of the Union is where Apple lays out the real developer toolkit (Photo: AJ Yorio, Unsplash)
WWDC 2026 iOS 27

The Keynote Made You Cry. The State of the Union Gave You Homework. Five Things That Actually Change Your iOS Workflow.

WWDC 2026 State of the Union broke open the developer toolbox: free Private Cloud Compute for indie devs, Foundation Models going open source, Xcode 27's Device Hub killing Simulator, agentic coding with Claude and Gemini inside your IDE, and SwiftUI finally caching images like it should have from day one.

10 min read
A bright orange DETOUR road sign with a black arrow pointing right — the moment a request reroutes from the on-device model to the server.
Swift SwiftUI

ThinkBud + Foundation Models: What I Shipped On-Device, and the Wall That Sent Me Back to the Server

Day 10 of the 30-day iOS series, the build-in-public finale of AI week. I took the on-device Foundation Models stack from Days 8 and 9 and bolted it into ThinkBud, an app I actually ship. Here's the honest field report: the bounded tasks the on-device model nailed for free and offline, the context-window wall a 100K-character textbook import smashed into, and the exact line of code where I gave up and routed to a server. Plus the one decision that's pure Swift — so it gets a real test.

13 min read
A speaker presenting on a conference stage to a packed audience — the energy of a keynote that changes what you'll build next (Photo: Unsplash)
WWDC 2026 iOS 27

Tim Cook Wiped a Tear, Siri Got a Google Brain, and Apple Shipped a Transparency Slider. WWDC 2026, Honestly.

The WWDC 2026 keynote just happened. Tim Cook's emotional farewell, Siri rebuilt on Gemini, Core AI replacing Core ML, Xcode 27 going full MCP, and Liquid Glass finally getting a slider. Here's what actually matters for your iOS codebase — no press release fluff.

8 min read
A grid of metal letterpress type blocks set into wooden compartments — each slot a defined, typed character, the analog ancestor of structured output.
Swift SwiftUI

@Generable: Make Apple's On-Device Model Hand You a Swift Struct, Not a String to Parse

Day 9 of the 30-day iOS series, part 2 of AI week. Yesterday Foundation Models gave us a String. Today we make it give us a typed Swift value — BrewSummary(flavor:, advice:, rating:) instead of a paragraph you regex your way through. @Generable, @Guide constraints, session.respond(to:generating:), and the sleeper-within-the-sleeper: tool calling, where the on-device model calls your own Swift code mid-answer. With the TDD seam, because typed output changes what you test.

14 min read
An open notebook with the word 'Notes' handwritten and underlined, a fountain pen resting on the page, reading glasses blurred behind it — the raw input a summarizer turns into one clean line.
Swift SwiftUI

Foundation Models: Your First On-Device AI Feature With No Backend, No API Key, No Bill

Day 8 of the 30-day iOS series, and the start of AI week. The Foundation Models framework runs a real language model entirely on the phone — free, private, offline. We build the smallest thing that works: summarize a block of text in three lines, handle the availability cases that bite in production, wire it into a real app, and put a TDD seam around the part that isn't the model. Code-along, with tests.

12 min read
A building wrapped in scaffolding mid-renovation — the new facade isn't up yet, so the old one stays protected. The same call you make with UIDesignRequiresCompatibility while your redesign is still in flight.
Swift SwiftUI

UIDesignRequiresCompatibility: When (and Why) Opting Out of Liquid Glass Is the Pro Move

Apple hands you one Info.plist key that freezes the old design for a full year. It's not a cop-out — for banking, enterprise, and apps caught mid-redesign, opting out of Liquid Glass is the responsible call. The exact flag, a real before/after from my own app, the deadline, and a decision matrix you can actually defend in a standup. Plus the per-screen rollout gate you should be testing instead.

11 min read
Light refracting through layered glass into a spray of color — the same object reading differently under different light, the way one Icon Composer document renders as light, dark, clear, and tinted.
Swift SwiftUI

Icon Composer and the New App-Icon Era: One Document Instead of Three Exported PNGs

iOS 26 wants your app icon in light, dark, clear, and tinted. The old way was three flat 1024px PNGs that quietly drifted apart. Icon Composer turns it into one layered .icon document the system relights for you. The real workflow from a single SVG to a full set — plus the one decision around icons you can actually unit-test.

12 min read
Orange and teal ink diffusing through water, translucent layers blending and morphing into each other — the visual metaphor for layering and morphing Liquid Glass effects.
Swift SwiftUI

Custom Liquid Glass Components: When to Leave the Defaults (and the Three Mistakes That Kill Your Frame Rate)

glassEffect(.regular, in:) with a custom shape, two glass blobs that morph into each other with glassEffectID, and the three things that turn buttery Liquid Glass into a stutter machine. Built on a real iPhone 17 Pro simulator, with the TDD seam that keeps the decision testable even though the render isn't.

12 min read
A dramatic red theater curtain on an empty stage — symbolizing Tim Cook's final WWDC keynote curtain call before handing the CEO role to John Ternus
WWDC 2026 Tim Cook

Tim Cook's Curtain Call: His Last WWDC Keynote and What Changes for Every iOS Developer

Tim Cook delivers his final WWDC keynote on June 8 before handing the CEO role to hardware chief John Ternus on September 1. After 15 years, a $350B-to-$4T run, and a developer ecosystem of 2.3 billion devices, here's what the transition actually means for people who write Swift for a living.

10 min read
Close-up of textured, refractive glass with warm amber-to-cream tones — the real-world material Apple's Liquid Glass design language imitates on screen.
Swift SwiftUI

Liquid Glass for an App You Already Shipped: What You Get From a Recompile vs. Five Lines of Tuning

I rebuilt a real SwiftUI app against the iOS 26 SDK and took two screenshots of the exact same screen — one with zero code changes, one with five lines of glassEffect. Here's the honest split between what the recompile hands you for free and what's worth your custom-tuning time, plus the TDD seam that makes a visual feature testable.

10 min read
A laptop glowing in the dark, casting blue and orange light — reflecting Apple's 'All Systems Glow' WWDC 2026 tagline and the divided developer sentiment
WWDC 2026 iOS 27

Apple Said 'All Systems Glow.' Developers Said 'Not So Fast.'

Apple dropped its WWDC 2026 tagline yesterday and the developer forums immediately caught fire. Half the community is excited for iOS 27's AI overhaul. The other half is already mourning the operating system they used to love. With six days until the keynote, here's what the divide tells us about where Apple is headed.

9 min read
A smartphone with colorful glass-like reflections representing Apple's mandatory Liquid Glass design language in iOS 27
iOS Development Liquid Glass

Your App Just Got an Eviction Notice: Liquid Glass Is Mandatory in iOS 27

Apple confirmed Liquid Glass is non-negotiable in Xcode 27. Your custom tab bars, navigation views, and carefully crafted layouts are about to meet a wrecking ball called UIDropShadowView. Here's exactly what breaks, what the timeline looks like, and how to survive the migration before WWDC drops on June 8.

9 min read
iPhone capturing an AI visualization on a laptop screen — representing Apple's native MCP support turning every iOS app into a tool for AI agents
iOS Development MCP

Apple Is Turning Every App Into an AI Tool — MCP Support Means Siri Was Just the Warm-Up

Apple is building native Model Context Protocol support on top of App Intents. That means Claude, ChatGPT, Gemini, and every other AI agent will be able to control your app — not just Siri. Nine days before WWDC 2026, here's what this means for iOS developers and why your App Intents just became the most important code you've ever written.

10 min read
Lines of code on a dark screen — the kind of code that's about to get a major AI upgrade when Apple drops its new developer platform at WWDC 2026
WWDC 2026 iOS 27

Apple Registered genai.apple.com. Twelve Days Before WWDC, the Biggest Clue Just Dropped.

Apple quietly registered a GenAI subdomain last week. It's not live yet, but the timing — twelve days before WWDC 2026 — tells us everything about where the iOS developer platform is headed. Core AI, Siri Extensions, Foundation Models, and a public-facing AI hub. Here's what it means for your next project.

9 min read
Lines of code with colorful syntax highlighting on a dark screen — representing Swift development breaking free from Xcode into AI-powered IDEs like Cursor and Kiro
Swift Cursor IDE

I Wrote Swift in Cursor for a Week. Xcode, We Need to Talk.

Swift officially hit the Open VSX Registry — meaning Cursor, Kiro, and every AI IDE now support Swift with full LSP, debugging, and test explorer. I spent a week building iOS code outside Xcode. Here's what worked, what didn't, and why Apple publishing a Cursor setup guide is the most understated power move of 2026.

8 min read
A close-up of frosted glass with soft textures and gradients — a visual metaphor for Apple's Liquid Glass design language and its translucency controversy
iOS Development Liquid Glass

Liquid Glass Turns One. We're Still Squinting.

Apple's Liquid Glass design language is celebrating its first birthday — and the party is divided. With WWDC 2026 two weeks away and iOS 27 doubling down, here's where things actually stand for developers: the wins, the accessibility mess, the adoption gap, and why your next SwiftUI update might need reading glasses.

9 min read
A close-up of a professional camera lens with warm light reflections — representing the new AI-powered Visual Intelligence pipeline Apple is bringing to iOS developers
WWDC 2026 iOS 27

Visual Intelligence Is the Sleeper Hit of WWDC 2026. Most Developers Don't See It Coming.

Apple is opening Visual Intelligence to third-party developers at WWDC 2026 — nutrition scanning, contact capture, Wallet passes, and a full camera AI pipeline. While everyone argues about Siri, this is the API that will actually change how your app works. Here's what we know and how to prepare.

7 min read
Colorful sticky notes pinned to a planning board — the analog version of what your Xcode project needs right now
WWDC 2026 iOS 27

WWDC 2026 Is 26 Days Away. This Is Your iOS Developer Pre-Flight Checklist.

WWDC 2026 lands June 8. SiriKit deprecation, Core AI replacing Core ML, Liquid Glass refinements, foldable iPhone APIs, and strict concurrency in Swift 7. Here's the practical pre-flight checklist to run through your codebase right now — before the keynote makes it urgent.

8 min read
A financial growth chart on a monitor with bokeh lights in the background — representing the explosive App Store growth in 2026
App Store AI

The App Store Just Had Its Biggest Quarter in History. Here's Why That's a Problem.

App Store submissions are up 80% on iOS. AI coding tools turned everyone into a developer overnight. But when 200,000 new apps hit the store every week, the question isn't whether you can build an app anymore — it's whether anyone will find it.

8 min read
iPhone home screen showing Siri Suggestions with app icons — representing how AI-powered discovery is becoming the primary way users find and launch apps
iOS Development App Intents

App Intents Are the New SEO — and Most iOS Developers Are Still Invisible

Siri is becoming the front door to every iPhone. App Intents are no longer a nice-to-have — they're the difference between discoverable and dead. Here's a practical guide to making your app visible before WWDC 2026 changes the rules.

9 min read
A developer workspace with a MacBook showing code on screen — representing the daily reality of working with AI coding agents in Xcode
Xcode AI

I've Been Pair Programming With Xcode's AI Agent for 3 Months. We Need to Talk.

Xcode 26.3 shipped agentic coding with Claude and Codex in February. Three months later, here's what it's genuinely great at, where it falls apart, and why it made me rethink how I write SwiftUI code — for better and worse.

10 min read
Colorful thread spools organized neatly on shelves — a visual metaphor for Swift's newly organized approach to concurrency
Swift Swift 6.2

Swift 6.2 Finally Made Concurrency Approachable — Someone Already Built a Parody Site

Swift 6.2 ships @MainActor by default, the new @concurrent attribute, and a complete rethink of strict concurrency. We break down what changed, show real migration code, and explain why the community is both celebrating and arguing.

9 min read
Two monitors displaying code side by side — representing the Claude Code vs Cursor developer tool comparison
Claude Code Cursor

Claude Code vs Cursor: I Used Both for a Month. One Tried to Charge $1,400.

Cursor is the sous chef who hands you the knife before you ask. Claude Code is the contractor who remodels your kitchen overnight. We tested both on real iOS projects and here's when each one wins — plus how to avoid that terrifying billing surprise.

10 min read
The Swift programming language logo displayed on an Android smartphone — representing Apple's official Swift SDK for Android
Swift Android

Swift 6.3 Now Officially Runs on Android. I Tried It. Here's What Actually Works.

Apple shipped an official Swift SDK for Android with Swift 6.3. Not a hack, not a community port — the real thing. We tested it on a real project and here's every win, every friction point, and the honest verdict on whether iOS developers should care.

9 min read
iOS 26 home screen showing app icons in default, tinted, and dark variants — the new Liquid Glass icon system that demands three versions of every app icon
iOS 26 Liquid Glass

We Updated Our App Icon for iOS 26. Apple Now Wants Three of Them. So We Built a Tool.

iOS 26 Liquid Glass quietly tripled the work to ship an app icon — default, tinted, and dark variants for every iPhone app. Existing icon tools haven't caught up. We hit the wall updating ThinkBud last week, so we built a free generator. Here's what changed in iOS 26, why every iOS dev is about to learn this the hard way, and the tool we shipped to handle it.

10 min read
Monitor displaying code in a dark development environment — representing the late-night Xcode 26 migration sessions developers are pulling before Apple's SDK deadline
iOS Development Xcode 26

Apple's iOS 26 SDK Deadline Hits Tomorrow. Half the App Store Isn't Ready.

April 28, 2026 — every app submitted to the App Store must be built with Xcode 26 and the iOS 26 SDK. If you haven't updated yet, your next submission gets rejected. Here's what's breaking, what you need to fix, and why this deadline is different.

10 min read
Glassy abstract iOS interface — representing the SwiftUI and SwiftData layer that underpins modern iOS apps in 2026
SwiftData Core Data

I Migrated Two Apps to SwiftData. Eighteen Months Later, I'm Migrating Half of It Back.

SwiftData turns three at WWDC 2026. After running it in production across two shipping iOS apps for a year and a half, here's an honest field report — what works, what quietly broke, and the three places we went back to Core Data and don't regret it.

10 min read
Close-up of colorful programming code on a dark screen representing intensive AI-powered code refactoring session
AI Claude

We Gave Claude Mythos Full Access to Our Codebase. It Shipped Three Features Before Lunch.

After a week of security testing, we let Anthropic's most restricted AI model loose on real development work. It refactored our state management, found a memory leak we'd chased for months, and rewrote our networking layer across four apps. Week two was a different beast.

8 min read
Apple WWDC 2026 official event branding — the developer conference bringing foldable iPhone APIs, Core AI framework, and major platform changes
WWDC 2026 iOS 27

Apple Is Shipping Foldable iPhone APIs Before the Foldable iPhone. That's Either Genius or Chaos.

WWDC 2026 drops June 8. Apple is giving developers fold-state detection, Core AI replacing Core ML, macOS touch APIs, and a Siri that lives in the Dynamic Island. Here's what you need to know and what we're already building.

9 min read
Close-up of an Apple silicon chip highlighting the Neural Engine that powers on-device AI in iPhones and iPads
Foundation Models Apple Intelligence

Apple Put a 3-Billion Parameter Brain Inside Every iPhone. Most Developers Haven't Even Noticed.

Apple's Foundation Models framework lets you run AI on-device with 3 lines of Swift. No API keys. No cloud bills. No privacy headaches. Here's why iOS developers should stop ignoring the smartest thing Apple shipped in years.

11 min read
Leaked dummy models of the Apple iPhone Fold alongside iPhone 18 Pro models showing the book-style foldable form factor
iPhone Fold iOS Development

The iPhone Fold Ships in September. Your App Layout Just Had a Panic Attack.

Apple's foldable iPhone has entered trial production. A 7.76-inch inner display, book-style fold, and no Face ID. SwiftUI developers have a head start. UIKit holdouts should start stretching.

9 min read
Apple WWDC 2026 event branding — the annual developer conference where Apple is expected to open Siri to third-party AI chatbots
WWDC 2026 iOS 27

Apple Stopped Pretending It Could Build AI Alone. That's the Best WWDC News in Years.

WWDC 2026 is two months away. Apple is opening Siri to Claude, Gemini, and Grok. Xcode already has agentic coding. iOS 27 is a stability year. Here's what iOS developers actually need to care about.

8 min read
Apple's Liquid Glass design language showcased across iOS devices — the translucent, frosted interface that divided the developer community
Liquid Glass iOS Design

Apple Gave iOS a Makeover Nobody Asked For. Now Everyone Has to Live With It.

Liquid Glass is permanent, expanding, and mandatory in iOS 27. Apple's VP of design left for Meta. Developers lost customization options. Users can't read their screens. And Apple just told everyone to deal with it.

9 min read
Vibe Coding in iOS Development - Comprehensive analysis of AI models and tools
Vibe Coding AI

Vibe Coding in iOS Development: A Comprehensive Analysis of AI Models, Tools, and Workflows

After months of testing every major AI model and coding tool for native iOS development — from OpenAI to Anthropic, Cursor to Claude Code — here is what actually works, what does not, and why Claude Opus 4.6 changed everything.

15 min read
Native vs Cross-Platform - Why we choose native Apple development
Development Apple

Why We Choose Native Over Cross-Platform

Our philosophy on building native Apple apps instead of using cross-platform frameworks, and why we believe native development leads to better user experiences.

4 min read