Blog
Essays, notes, and small SwiftUI experiments — written to be calm, practical, and useful.
Property Wrappers as API Design
An essay about treating property wrappers as boundaries, not magic syntax.
App Intents and Siri Boundaries
A short SwiftUI note on keeping App Intents thin, explicit, and easy to reason about.
Foundation Models and Feature Boundaries
An essay about keeping AI features explicit, testable, and safely bounded inside a SwiftUI app.
What's New in SwiftData
A practical note on reading SwiftData updates through ownership, previews, and feature boundaries.
Preview Dependency Injection Workflow
A step-by-step SwiftUI tutorial for wiring previews with the same dependencies your feature uses in the app.
Xcode 27 Beta: Agentic Coding Workflows for SwiftUI
A short SwiftUI note on using agentic coding workflows without losing review discipline.
What's New in SwiftUI for 2026
A practical way to read the WWDC26 SwiftUI changes through ownership, layout, and recomposition.
List Row State Reset Fixes
A quick SwiftUI checklist for fixing row state that resets or jumps after list updates.
Task Cancellation in Infinite Lists
A step-by-step SwiftUI tutorial for loading row data in a scrolling list without wasting work when rows disappear.
Side Effect Boundary Checklist
A quick SwiftUI checklist for keeping task, onAppear, and onChange work in the right place.
Side Effects in SwiftUI: task vs onAppear vs onChange
A practical SwiftUI essay for deciding where side effects belong when views recompute and appear repeatedly.
MainActor: What To Mark and Why
A short SwiftUI note for deciding when @MainActor belongs on a type or method.
Dismissible Banner with Queueing
A step-by-step SwiftUI tutorial for building a dismissible banner that queues messages instead of dropping them.
Matched Geometry Accessibility Checklist
A quick SwiftUI checklist for checking matched-geometry motion before it reaches users.
Reduced Motion Fallbacks for Navigation
A practical SwiftUI essay about keeping navigation understandable when motion should be simplified.
Navigation Motion Accessibility Checklist
A quick SwiftUI checklist for keeping motion-heavy navigation usable when animations need to be reduced.
Preview Dependency Injection Checklist
A quick SwiftUI checklist for keeping previews realistic when a feature uses environment values and injected services.
Observation vs. StateObject in SwiftUI
A practical guide to choosing between Observation and StateObject without losing track of ownership.
Observation Migration Checklist
A quick SwiftUI checklist for moving a screen to Observation without blurring ownership.
Migrating ObservableObject to @Observable
A step-by-step SwiftUI tutorial for moving a screen from ObservableObject to the Observation framework without losing ownership clarity.
Feature-Scoped Environment Values
A small SwiftUI pattern for keeping environment values explicit, testable, and tied to one feature boundary.
Observation in SwiftUI: Ownership After iOS 17
A practical mental model for using SwiftUI Observation without losing track of who owns the model.
Why @State Is More Powerful Than Most SwiftUI Developers Think
A mental model for seeing @State as owned storage tied to view identity, not just a convenient place for local variables.
ForEach Identity Debug Checklist
A quick SwiftUI checklist to debug list glitches caused by unstable ForEach identity.
SwiftUI Identity: Stable IDs, Stable Behavior
A practical mental model for SwiftUI identity and why stable IDs are essential for reliable updates, animations, and state retention.
Modifiers Are Order-Dependent in SwiftUI
A focused SwiftUI note on why modifier order changes behavior, with practical examples for predictable UI code.
Creating a Custom ButtonStyle Systematically
A step-by-step SwiftUI tutorial for building reusable button styles with consistent states, tokens, and accessibility behavior.
Environment Key Patterns for Features
A practical note on defining SwiftUI Environment keys that stay explicit, testable, and feature-friendly.
Why Environment Is Dependency Injection
A practical mental model for using SwiftUI Environment as dependency injection without hiding ownership and boundaries.
SwiftUI Shapes Are Descriptions, Not Views
A mental model for understanding SwiftUI shapes as geometry descriptions instead of UI elements.
Using @FocusState for Better Form UX
A practical SwiftUI tutorial for managing field focus, keyboard navigation, and validation flow with @FocusState.
SF Symbols: Icons as Design Data
A perspective on SF Symbols as scalable design primitives, not image assets.
Enums in Swift: Models, Not Switches
Why Swift enums are powerful modeling tools, not just control flow helpers.
Property Wrappers in Swift: Boundaries, Not Magic
A mental model for understanding Swift property wrappers as explicit boundaries of responsibility.
Animating View Transitions with .transition
A practical SwiftUI tutorial for building smooth insertion and removal animations with transition, state ownership, and predictable layout behavior.
ViewThatFits: Adaptive Layouts in SwiftUI
Build adaptive SwiftUI layouts with ViewThatFits by declaring fallback variants instead of writing manual size logic.
SwiftUI ToolbarSpacer
A tiny SwiftUI trick to create separation.
Understanding Swift async/await: Flow, Not Syntax
A mental model for Swift’s async/await that focuses on execution flow instead of keywords.
Why your SwiftUI body must stay cheap
A short explanation of why expensive work does not belong in SwiftUI view bodies.
Building a Settings Row with Toggle and Detail
A step-by-step SwiftUI tutorial for a reusable settings row that supports toggle state, optional detail text, and clear ownership boundaries.
@Binding is not shared state
A clarification of why @Binding does not represent ownership or shared state in SwiftUI.
How to Structure a SwiftUI View File (A Beginner’s Guide)
A beginner-friendly mental model for structuring SwiftUI view files, including bindings, state, body, and methods.
Why onAppear Is Not Lifecycle
A short SwiftUI note on why onAppear should not be treated like UIViewController lifecycle.
Passing Bindings Through Multiple View Layers
A step-by-step SwiftUI approach to forwarding bindings through nested views without losing ownership clarity.
Callback Closures vs Bindings in SwiftUI
How to decide whether a child view should receive a Binding or an action closure.
Data Flows Down, Actions Flow Up
A practical mental model for designing SwiftUI screens that stay predictable as they grow.
Xcode: How to Navigate Large Swift Files Quickly
A short Xcode guide with practical navigation tricks and shortcuts for Swift files.
Guard vs. If Let in Swift (and when to use each)
A practical mental model for choosing guard, if let, and optional handling patterns in Swift, with comparisons to common patterns in other languages.
Understanding Optionals in Swift (and common pitfalls)
A practical beginner-friendly guide to Swift optionals: what they are, when to use them, and how to avoid common mistakes like force unwrapping.
Extracting a reusable SwiftUI component cleanly
How to refactor a SwiftUI view into a reusable component without breaking data flow.
Why SwiftUI views are structs (and why that matters)
A brief explanation of why SwiftUI uses value types for views and how that shapes the framework.
Why SwiftUI Recomposes Views (and Why That’s Fine)
A clear mental model explaining why SwiftUI recomputes views and how to design with it instead of fighting it.
Building an expandable add button in SwiftUI
A simple floating action button that expands into multiple actions using pure SwiftUI.
Views are value types, not objects
Why SwiftUI views behave differently than UIKit views — and why that is a feature, not a limitation.
State vs Binding: A Mental Model
A simple mental model for deciding when to use @State and when to use @Binding in SwiftUI.
Preventing Screenshots in SwiftUI: What’s Possible (and What Isn’t)
An honest look at screenshot prevention in SwiftUI: platform limits, UIKit bridges, and realistic security expectations.
SwiftUI Is a Language for Data Flow (Not Layout)
SwiftUI is best understood not as a layout system, but as a language for expressing data flow and ownership. A calmer mental model for modern SwiftUI.