Skip to content
Looking for someone to build your mobile app?See my mobile work
Writing

Blog

Notes on building for the web and mobile: performance, architecture, AI, and the craft of shipping.

SeriesTopicsRSS feed

2
series
32
articles
24
Topics
View all series

React Native → Swift

Native iOS for senior React Native engineers: what really changes in Swift, SwiftUI, state, navigation, data, concurrency, persistence, tooling and the App Store, and what you can only do in native.

13 articles

Agent loop

Building a coding agent from scratch, one loop at a time, every part in runnable code.

8 articles

All articles

Jev illustration: a state enters a decision node and comes out as three typed values, a yes or no, a choice and a score, with no text in between
AI23 Sep 202613 min read

What is Jev: TypeSafe AI's model that decides instead of writing

What is Jev, TypeSafe AI's System One model: it returns typed decisions with probabilities instead of text. How to call its API, what it costs and when to use it.

Read more
Illustration: the client's money travels along a copper path that stops at a locked box, and only continues to the developer once a delivery marked with a check crosses the other way; below, a secondary path leads to a scale
Product23 Sep 202616 min read

Why hire me through Upwork: protected payments, a verifiable track record and arbitration

What you gain by hiring through Upwork: money in escrow until you approve each milestone, auditable hours, a track record nobody can edit, and arbitration.

Read more
Illustration: irregular, muted blocks piled up with no order pass through a copper reading line and come out as three ordered rows inside a document, two marked with a tick and one discarded
Product19 Sep 202616 min read

You inherited a product: the code audit before you continue

What a code audit reviews when you inherit a product from another team, what the written verdict says, and how to decide between keeping, fixing and rewriting.

Read more
Illustration: a loose ticket that ends in a block of code, next to a continuous path that runs from the decision through building, launching and maintaining a product
Product19 Sep 202615 min read

What is a product engineer, and how is that different from a programmer?

What a product engineer does, how the role differs from a programmer, and how to tell which of the two your business needs before you hire anyone.

Read more
Illustration of an app in the center surrounded by system surfaces: a widget, a dynamic island, a watch and a local model symbol, all connected to it
Mobile13 Sep 202617 min read

What you can only do in native: WidgetKit, Live Activities, App Intents, StoreKit 2, Foundation Models and watchOS

The iOS capabilities React Native does not offer and that justify Swift to a client: WidgetKit, Live Activities, App Intents and Siri, StoreKit 2, the on-device language model with Foundation Models and watchOS. Series close and sales argument.

Read more
Illustration of a table of cases where each row is compared against a reference, next to a stopwatch that represents build time
Mobile12 Sep 202616 min read

iOS testing and tooling for seniors: Swift Testing, snapshots, mocks, Instruments and build times

How to test an iOS app coming from Jest and Testing Library: Swift Testing versus XCTest, snapshot testing, mocks via protocols and URLProtocol without jest.mock, XCUITest versus Maestro, Instruments, SwiftLint and modularizing to cut build times.

Read more
Illustration of a chain of links joining a certificate, a profile and a signed package, with a seal at the end representing the review
Mobile11 Sep 202616 min read

Build, signing and the App Store: what EAS hid from you

What EAS Build did for you and is now yours: certificates, provisioning profiles and entitlements explained once, Fastlane match for team signing, TestFlight, the App Review guidelines that reject the most, the Privacy Manifest and Tuist.

Read more
Illustration of a shape that transforms in three phases toward another position, with a scale of text sizes and a symbol to one side
Mobile10 Sep 202615 min read

UI, theming and animations in SwiftUI without NativeWind or Reanimated

How to do theming, animations and accessibility in SwiftUI coming from NativeWind and Reanimated: design tokens in the Asset Catalog, Dynamic Type as the default, SF Symbols, withAnimation, matchedGeometryEffect, PhaseAnimator, native gestures and Liquid Glass as a day-one API.

Read more
Illustration of a row of small modules on the left connected one to one with system blocks on the right, with one block marked as the main one
Mobile9 Sep 202617 min read

From the expo-* ecosystem to Apple frameworks: the equivalence table by domain

Which Apple framework replaces each expo-* package when you move from React Native to native iOS: camera, location, authentication, payments, notifications, files and more, with the Info.plist permissions and the silent crash everyone hits once.

Read more
Illustration of three stacked storage layers, with a separate sealed box representing the Keychain and a cloud syncing with the main layer
Mobile8 Sep 202614 min read

iOS persistence: SwiftData, GRDB and Keychain, and why Realm is no longer an option

How to choose between SwiftData, GRDB and Core Data to persist data in an iOS app, why Realm stopped being an option, why the Keychain survives uninstalling, and how to design offline-first and sync with CloudKit.

Read more
Illustration of sanitype: a payload crosses a boundary and comes out with its sensitive fields masked, plus a report of what was touched
AI7 Sep 202620 min read

Sensitive data out of the prompt: a TypeScript library written in 39 minutes from its specification

sanitype redacts, masks or drops sensitive data inside the process before a payload leaves for an LLM, a log sink or a third party. How it is implemented in TypeScript.

Read more
Illustration of several tasks running in parallel inside one frame and converging on a single exit point, with an isolated actor to one side
Mobile7 Sep 202616 min read

Swift concurrency: goodbye event loop. async let, TaskGroup, actors and Swift 6

Swift Concurrency for people coming from JavaScript: why there is no event loop, how async let and TaskGroup replace Promise.all, what actors and @MainActor are, what Sendable requires and why in Swift 6 a data race is a compile error.

Read more
Illustration of a data layer: the network and a local store feed a single stream that reaches the view, with the cache as the primary source
Mobile6 Sep 202616 min read

Data in Swift: what TanStack Query did for you and how to build your cache layer

There is no TanStack Query in Swift. How to design the data layer of an iOS app with URLSession and Codable, a repository that emits with AsyncStream, SwiftData or GRDB as the local cache, invalidation and supabase-swift.

Read more
Illustration of Spec-Driven Development: a specification turns into acceptance criteria and from there into the earthquake list of a mobile app
AI5 Sep 202623 min read

Spec-Driven Development in React Native: an MVP that lists the world's earthquakes, specified before writing code

I applied Spec-Driven Development to a React Native MVP that lists the world's earthquakes: the specification decides what goes in the list, and its acceptance criteria become the tests.

Read more
Illustration of a stack of screens piled in depth, with an external link entering an intermediate screen directly
Mobile5 Sep 202614 min read

SwiftUI navigation without file-based routing: NavigationStack, a Route enum and deep links

How to move mentally from Expo Router to SwiftUI: NavigationStack with a Route enum, the Coordinator pattern, deep links and Universal Links, and what swift-navigation adds when sheets and alerts become state.

Read more
Illustration of a central state feeding views that only observe the part they read, with separate modules around it
Mobile4 Sep 202616 min read

State and architecture in SwiftUI: from Zustand and Redux to @Observable and TCA

How to manage state in SwiftUI coming from Zustand and Redux: MVVM with @Observable as the default, when TCA justifies its learning curve, dependency injection with swift-dependencies or Factory, and why to modularize into packages from day one.

Read more
Illustration of a voice agent: a call comes in, a backend resolves dates and options, and a confirmed appointment comes out on the calendar
AI4 Sep 202625 min read

Voice agent that books appointments: ElevenLabs, Cal.com and a backend that never lets the model guess

How I built a voice agent that books 30-minute appointments with ElevenLabs and Cal.com, and why the Fastify backend is what keeps the model from inventing times.

Read more
Illustration of a view tree where each node proposes a size to its children and receives an answer, with a main path highlighted
Mobile3 Sep 202616 min read

SwiftUI is not React, even if it looks like it: body, identity, modifiers and layout

SwiftUI explained for people coming from React: what body is compared to render, why a view's identity matters, how modifier order changes the result, the layout system without flexbox and the map from hooks to property wrappers.

Read more
Illustration of two type systems: a shape that gets copied as it passes from hand to hand and another that is shared by reference, with a container that may be empty
Mobile2 Sep 202617 min read

Swift for people who already master TypeScript: the five differences that change how you design

Swift explained for TypeScript developers: value vs reference semantics, optionals as part of the type system, enums with associated data, protocols with extensions, and Codable instead of zod.

Read more
Illustration of two paths leaving the same point: one covers two platforms with a single layer and the other reaches the system's capabilities directly
Mobile1 Sep 202617 min read

Why a senior React Native developer should learn native in 2026

When native iOS beats React Native (widgets, day-one APIs, on-device ML), when it loses (two platforms, OTA, team) and why learning Swift adds to your toolkit instead of replacing it.

Read more
Illustration of an agent's hard limits: the agent loop enclosed in a frame of checks—budget, command allowlist, path allowlist—with a kill switch outside and a log of every turn
AI31 Aug 202633 min read

The hard limits of an autonomous agent: what keeps it from disaster

The limits that separate an experiment from an agent you'd leave running: iteration and token caps treated as a budget, command and path allowlists, a kill switch, idempotency and observability.

Read more
Data annotation illustration: a person trains a robot by approving a labeled example with a check mark while the training signal flows toward the robot
AI25 Jul 202613 min read

Data annotation jobs: what labeling and reviewing AI responses involves

What data annotation jobs and AI response review are: the tasks involved, how they feed model training (RLHF), and how annotator quality is measured.

Read more
Illustration of an agent fleet: a prompt fans out to several agents in parallel, each in its own worktree
AI6 Jul 202616 min read

Orca: the ADE for orchestrating a fleet of coding agents in parallel

I tried Orca, the open-source Agent Development Environment (ADE), to run a fleet of coding agents in parallel—Claude Code, Codex and more, each in its own isolated worktree.

Read more
Illustration of the end-to-end system: a Jira ticket enters through a trigger, passes through a stateful queue, runs in an ephemeral workspace, and comes out as a pull request that returns to Jira as a comment
AI2 Jul 202629 min read

From a Jira ticket to a pull request: the end-to-end autonomous system

How I turned the agent into an autonomous system: a Jira ticket triggers it (webhook or polling), a queue with persistent state processes it exactly once, and it returns a PR and a Jira comment.

Read more
Illustration of an isolated agent: a separate working copy branches off the repository on its own branch, the loop works inside it, and the output is a pull request, not a merge
AI30 Jun 202619 min read

The agent inside a real repo: isolating tasks with git worktree and shipping a PR

How to put an agent loop to work on a real repository: isolate each task with git worktree, reproduce the bug with a test, run the whole suite, and ship a PR instead of a merge.

Read more
Illustration of the ReAct loop: an agent picks among four tools—read, search, write, run—and builds its own context with each observation
AI30 Jun 202621 min read

From generating files to using tools: a code agent's ReAct loop

The shift from generating the whole function to an agent that reads, searches, edits, and runs with tools: the ReAct loop and why the agent builds its own context instead of receiving it in the prompt.

Read more
Illustration of three levels of input for an agent: hand-written tests, examples the agent turns into tests, and the repo's existing suite as the evaluator
AI30 Jun 202624 min read

Who writes the agent's tests: three ways to define what's correct

Who writes an agent's tests defines what counts as correct. Three levels of input: spec and tests by hand, examples the agent turns into tests, or the repo's suite as the evaluator.

Read more
Execution sandbox illustration: the model's text enters an isolated enclosure with a timer, passes through four filters, and comes out as a classified observation
AI30 Jun 202621 min read

The sandbox in an agent loop: from the model's text to a reliable observation

The sandbox in an agent loop turns the model's text into a reliable observation: extract the code from the prose, check that it parses, run it with a timeout, and isolate the process.

Read more
Write-test-fix loop illustration: one node writes code, another tests it, and the failure feeds back as context until the tests pass
AI30 Jun 202624 min read

The simplest loop that works: a write-test-fix agent, step by step

The simplest agent that works: spec and tests by hand, the model writes the code, it runs, and the failure feeds back as context. A complete write-test-fix loop in code that runs.

Read more
Agent loop illustration: a goal enters a cycle of decide, act, and observe that repeats until a stopping condition
AI29 Jun 202612 min read

What an agent loop is (and isn't): state, action, stop

What an agent loop is and isn't: its three components—state, action, and stopping condition—and why 'build me an app' is input for a chat, not an agent.

Read more
Model routing illustration: a request is split across several models, with most of the traffic going to the main model
AI29 Jun 202625 min read

Model routing with OpenRouter and DeepSeek to cut costs without losing quality

How I routed models in production with OpenRouter, using DeepSeek for the bulk of traffic and premium models only where it matters, cutting LLM costs without degrading quality.

Read more
Illustration of a news pipeline: several RSS feeds converge into a flow that filters, rewrites with AI, and publishes a draft
Automation29 Jun 202617 min read

I automated a news site with n8n: from 20 RSS feeds to WordPress drafts

How I built an n8n pipeline that reads 20 RSS feeds, deduplicates with Postgres, curates and rewrites with tiered AI, and leaves the article as a WordPress draft with an image and a Telegram alert.

Read more