Tobias Reinsch Writing
Notes on building mobile apps: architecture, Swift and Kotlin, testing, and how AI agents change the day-to-day work. Also available as RSS.
2026
-
How I split the work with coding agents
I use coding agents every day. They make implementation cheaper; they don't make the decisions that keep an app maintainable. Four rules for who does what.
-
Testing code you didn't write: the trust framework for agentic development
When an agent generates a non-trivial feature quickly, how do you know it's correct? Here's the review and testing framework I use to make generated code production-worthy.
-
How I kept this blog fast without giving up React
I used to think SSG and rich interactivity were mutually exclusive. Astro's island architecture let me keep most of the site static and add JavaScript only where it earns its keep.
-
SwiftData in production: where it shines and where it doesn't
SwiftData promised to replace Core Data's boilerplate with a modern Swift API. In production, the tradeoffs become clear around schema evolution, query expressivity, and operational risk.
-
Agents don't architect reliably: why system design still matters
AI agents can generate a feature quickly. They still usually can't tell you whether you should build it, where it should live, or how it should fit the system. Here's how I think about the architectural work that remains stubbornly human.
-
A practical iOS CI/CD setup in 2026: Fastlane, GitLab CI, and what ships well
If you want a production-ready iOS release pipeline with Fastlane and GitLab CI, this is a pragmatic setup that balances control, repeatability, and maintenance cost.
-
The feedback loop that changed how I write code
Agentic development tools didn't replace my workflow — they inverted it. I used to spend 80% of my time writing code and 20% reviewing it. Now the ratio is flipped, and my output is better for it.
2025
-
The physics behind fluid iOS interfaces
Most SwiftUI animation tutorials stop at .spring(). This one goes deeper — into damping ratios, response curves, and the physics that separate good apps from great ones.
-
Dependency injection in Swift without a framework
You do not need a DI framework just to say you use DI. Swift already gives most apps strong defaults, and libraries like swift-dependencies can still be a great fit when they solve real problems.
-
Why I stopped fighting state management and let TCA win
A practical journey from spaghetti ViewModels to The Composable Architecture, with an interactive visualization of how it actually works under the hood.
-
Instruments is the best debugging tool you're not using
After years of relying on print statements and Xcode's debugger, I finally went deep on Instruments. Here's the specific workflows that changed how I profile iOS apps — and the three tools every iOS engineer should know cold.
-
The hidden cost of view re-renders in SwiftUI
SwiftUI's diffing is fast, but it's not free. Here's how @Observable, EquatableView, and the shape of your state graph determine whether your app runs at 60fps or 30fps under load.
-
MVVM, VIPER, TCA — how they scale in practice
A practitioner look at how MVVM, VIPER, and TCA tend to scale in iOS teams, and why team habits matter more than architecture branding.
-
Swift concurrency: what the docs don't tell you about task lifetimes
async/await looks simple until a Task outlives the screen that created it. Here's what I learned the hard way about cancellation, structured concurrency, and the lifetime bugs hiding behind innocent-looking Task blocks.
-
What years of shipping iOS apps taught me about writing good software
Lessons from production iOS work on state management, premature abstraction, and knowing when good enough is good enough.
-
Swift macros are production-ready: here's how to write your own
Swift macros shipped in Swift 5.9 and the ecosystem spent a year learning when to use them. Many developers spent that year exploring them — including writing custom macros for production apps. This is what actually works.
2024
-
Kotlin Multiplatform from an iOS engineer's perspective
I've been integrating KMP into a production iOS app at my current job to share business logic with Android. Here's what it actually feels like to work with — the good, the surprising, and the places where Swift is still irreplaceable.
-
NavigationStack is not NavigationView: a practitioner's guide to data-driven navigation
SwiftUI's NavigationStack finally gave us programmatic navigation that works. After a year of production use across three apps, here's everything I wish I'd known from day one.