

Since Codifi I’ve used the time to go deep on native development: Android, the Apple Watch, a GNSS receiver over Bluetooth and ARKit. To have something real to build I started field capture over from what three years of Codifi taught me.
- What it is
- A field survey app on iPhone, Android, Apple Watch and the web. Not released.
- My part
- Every frontend: iPhone, iPad, Apple Watch, Android and the web app. A big hand in the backend’s design. I also carried the brand into each app. The AI that writes a project’s setup and the bank of 245 requests that scores it.
- When
- Since October 2026
- Built in
- Swift, SwiftUI and UIKit, with ARKit and Object Capture. Kotlin and Jetpack Compose. MapLibre on both. TypeScript and the Claude API for the AI.
What three years of Codifi taught me
At Codifi we talked every day with people working on boats and in the heat and the bright sun. Its schema kept their data clean and nobody left the field with a mess. What it missed was speed. Crews often just need to grab something now and sort it out later.
Some of what they asked for most was out of reach too. Codifi is React Native and its JavaScript can’t keep running in the background. A track of the day would have needed a third-party service to keep location on. That cost too much battery. Tephra starts from those gaps, in native code.
Capture now, classify later
In Codifi a crew had to say what a thing was before they could record it.
So I built a faster path. A photo, a note, a voice note or a shape goes in with one tap and shows only what matters in that moment. The app helps sort it into a full feature later and offers one from the captures nearby. When you already know what a thing is you can still record it in full straight away.

Controls for gloves and bright sun
Working with crews in the sun taught me what a phone is like outside. The screen washes out. Gloves miss small buttons. A soil color picked from a list of Munsell codes is easy to get wrong.
So I made the buttons bigger and the form shows a shovel test at a glance. Soil color is picked from chips you can see, each with its notation and name.

Scanning what stays in the ground
Archaeologists sort what they find. Diagnostic artifacts go back with them. Non-diagnostic ones are only documented and left where they lie. The record made in the field is all there will ever be.
A 3D scan of each one keeps far more than a photo. It also gave me a way into augmented reality. I learned Apple’s Object Capture by scanning a brick outside with no signal. I learned ARKit by setting the model back down on a counter.
A voice note on the wrist
In the field the phone is the device most likely to die. It collects all day while it runs the GPS. Crews end up carrying spare batteries. Some notes are quicker said than typed anyway and some hands are full.
So on the Apple Watch I made a voice note one tap. It stays on the watch until the phone is ready to take it, then plays on the phone and is turned into words there. Every note taken on the wrist is load the phone doesn’t carry.

When the phone dies the watch keeps the day
Survey crews have to account for the ground they cover. A track of the day was one of the things they asked Codifi for most and React Native couldn’t keep it running.
Native code can. So I built the day log: a light GPS track of the whole day kept in a pocket and saved as GPX, with a Live Activity on the Lock Screen and a Stop that works without opening the app.
- A walker’s settings. iOS rests the GPS while the phone stands still and wakes it when it moves. People stop all the time on a site.
- Fewer points. One every 10 meters. Nothing worse than 40 meters is kept.
- Written as it goes. A phone that dies keeps everything up to that moment.
The Apple Watch can take the day over. At 15% the phone offers it the day. The phone can’t start the watch itself. Its notification shows on the wrist though. One tap there carries the day on. If the phone dies the watch keeps recording and hands the file over once it’s charged.
A crew member can switch between the phone and the watch through the day and the track stays whole. Some people would rather keep the GPS on the watch from the start. They can.

Cutting a drive out of the day
Handing the day between devices makes one mistake easy. Someone forgets to stop and drives off with the log still running.
So I gave each day a screen of its own, with a calendar and each track’s map and elevation and a time to drag along it. The drive can be cut out of the track without deleting the day or losing the rest of the GPX.
On my first field test the GPS dropped out during a six-minute phone call and the track drew 4.2 km (2.6 miles) of road as one straight line. Now the file marks where the GPS was lost and starts a new line when it’s back. A day on the watch alone used 10% of its battery in 1 hour 37 minutes.

A dock built the way Find My’s is
Crews work from the map all day. Nothing should take it away. Find My does this well. It keeps a sheet over its map that never goes away and the map behind it keeps working.
People keep asking on Apple’s forums how to build it. SwiftUI’s sheet covers the tab bar. So the dock is a UIKit tab bar controller presented as the sheet itself, with SwiftUI pages inside.
The hard part was the bar. UIKit melts a tab bar into a sheet’s glass only near a detent with one private name. So the dock’s resting height is a public detent that carries the same name. I found it by tracing UIKit itself.

The same features on iOS and Android
React Native gave Codifi one codebase. Going native means building each feature twice, the way each system wants it. Android in Kotlin and Compose was one of the skills I set out to sharpen. I test it on the emulator and on a Samsung tablet.
A recording you can see and stop without opening the app
- iOS
- A Live Activity on the Lock Screen and in the Dynamic Island. Its Stop button runs an App Intent.
- Android
- A foreground service with an ongoing notification and Stop. Android 16 promotes it with a chip in the status bar.
Recording all day in a pocket
- iOS
- A background activity session and Core Location’s fitness updates. iOS rests the GPS while the phone is still.
- Android
- A location foreground service. It rests the GPS itself, woken by the significant-motion sensor.
A capture in one tap from the Lock Screen
- iOS
- Capture and Dictate controls for the Lock Screen and Control Center.
- Android
- Quick Settings tiles for a photo and a voice note.
On the wrist
- iOS
- A watchOS app for the day log and voice notes. The Live Activity has a Smart Stack layout too.
- Android
- Not started.
The sheet over the map
- iOS
- A UIKit tab bar controller presented as a sheet, with SwiftUI pages inside.
- Android
- A Compose dock with three heights of its own.
Dictation with field words
- iOS
- On-device speech with a custom language model for the field’s own vocabulary.
- Android
- On-device speech without the custom vocabulary.
A Bluetooth GNSS receiver
- iOS
- AccessorySetupKit to pair and Core Bluetooth to listen.
- Android
- Not started.
Talking to a GNSS receiver
Survey work needs better than a phone’s few meters. Agencies set how close a point has to be and a phone’s own GPS often can’t get there.
So I built the iPhone side of a Bluetooth receiver: the system’s own pairing picker, then NMEA sentences read as they stream in, each checked before anything trusts it. I tested it with a SparkFun RTK Facet.
In the recording the phone’s own fix is good to 7 meters. The Facet’s is good to 0.81 meters before any corrections.

$GNGGA,152846.00,3505.06400,N,10639.02400,W,2,12,0.8,1512.3,M,-23.4,M,1.0,0000*5D$GNGGA- GN: more than one satellite system. GGA: where you are.
152846.00- The time, 15:28:46 UTC.
3505.06400,N- Latitude, 35° 05.064′ north.
10639.02400,W- Longitude, 106° 39.024′ west.
2- The kind of fix. 2 is DGPS. 4 would be RTK fixed and 5 RTK float.
12- Satellites in use.
0.8- HDOP, how good the satellites’ spread is.
1512.3,M- Height above sea level, in meters.
-23.4,M- How far the geoid is from the ellipsoid there.
1.0,0000- How old the corrections are and the station they came from.
*5D- The checksum. Every character between $ and * run through XOR.
The ground it stands on
I build every frontend and I had a big hand in the backend’s design. What a capture is and what it can become started in my product docs. So did one coordinate system under every app and the way voice notes and 3D scans are stored. One rule in the database is mine alone. It never works out a number a person reads.
Every frontend Mine
- iPhone and iPadSwift and SwiftUI, with a database on the device
- Apple WatchRecords on its own and syncs through the phone
- AndroidKotlin and Compose, with a database on the device
- Web appReact and MapLibre
The platform
- One way in for changes
sync_pushapplies each once and in order - Rows back down
PowerSyncstreams each project to its phones - Files photos, recordings and 3D scans
- Sign-in one account in every app
Postgres with PostGISevery shape stored in WGS84
Saved on the device first. On the phones a capture never waits for a signal.
A face that shows what the AI is doing
I designed Tephra’s AI helper and built it in the web app. It plans a survey from the scope of work you paste in. It asks only what changes the plan and shows its steps before it starts. It draws the plan on the map as a draft and saves nothing until you accept.
An agent does a lot of its work where you can’t see it. So the helper needs a face that says what it’s doing. I made one from Tephra’s mark. I built a 3D model of it from the mark’s own coordinates as four glass plates. Straight on it’s still the flat mark. Each state moves the plates its own way.
This page follows the same rule as the app. Each clip loads the first time you press its state. The 3D engine loads only when you ask for the live shard.


At rest. Press a state to see what the helper shows while it works.
Weighing the formats
I rendered the same 2.4 second thinking loop in six formats and played each at the size it would ship. A GIF was 22 times the video’s weight and turned the glow grainy. Lottie can’t draw the glass at all.
- Video in the pane. One clip for each state at 7 to 20 KB. The video chip plays it so it costs almost nothing to run. Every clip starts on the same resting pose so a change of state never jumps.
- The still comes first. A 3 KB still shows before anything plays. It stays for anyone who asks for less motion. Safari in Low Power Mode won’t autoplay video so it stays there too.
- 3D only full screen. In the pane three.js would add two thirds to the web app’s first download. It loads when the full-screen start opens and draws only while it’s on screen. Then the shard flies into the pane and a video takes over.
- One model makes every clip. A script renders them all from the 3D model so a change to the glass re-renders every state. ffmpeg ignores the transparency in the iPhone’s files so I check it with Apple’s own decoder.
- Vector SVG24 px and under1 KB
- VideoThe pane13 KB
- Animated WebPA fallback63 KB
- Sprite sheetA fallback86 KB
- Live 3DFull screen only128 KB
- GIFNever293 KB
The video is WebM. Safari and the iPhone play the same clip as HEVC at 20 KB. Live 3D is three.js, loaded once for every state. The SVG and three.js are gzipped.
I built the AI that writes a project’s setup
You tell Tephra what the work is and add what you already have: a state’s guidelines as a PDF or the form you use now as an XLSForm. It proposes the overview first: what crews record and who gets what. The fields come once you say it looks right. Nothing is saved until a project admin accepts it.
The model never writes the setup itself. It fills in an outline through one tool and my code builds the setup from it. The builder keeps each question’s ID by its name so the records crews already made still match. A choice that goes away is retired and never deleted. The builder’s tests push everything it builds through the real sync.
I wrote the route behind it on Tephra’s worker on Google Cloud Run. It checks that the person is on the project before the model sees anything. Each turn is one call recorded as that person.
On the web I built the board it draws on. The overview is a flowchart in plain words whose boxes open in place. You can circle something with a pen to point Tephra at it. When you tell it to do something it just does it and gives you Undo.
i gotta go check the silt fences and the rock things at the entrances where the trucks come out and the straw tubes on the hill slope, see if any are busted or full of mud. boss wants pics of anything thats broke and where it is
The overview Tephra proposed
- On the map
- Silt fence
- Construction entrance
- Straw wattle
- Logs
- Control check
- Inspection walk
- Who gets what
- Boss
- A doubt
Passed all six checks in code
- Proposes the overview first
- Has a fence, a wattle or an entrance
- Has a check or an inspection Log
- Never talks about shovel tests or artifacts
- Never says anything is saved
- Never writes out coordinates
And the grader
“The names are right and unobtrusive, and the SWPPP question asks about a form without inventing a requirement.”
Three model calls with the grading, 4.3¢.
Scoring every change
I built a bank of 245 requests a person might type to set up their work. They run from heritage surveys to stormwater checks. Some are bullet lists and some are rambling dictation full of typos and the wrong trade words. Each one runs through the real route against the real model. Code checks what a rule can say and an AI grader reads the rest against what a good answer has.
What the failures share becomes a general rule in Tephra’s instructions. I never patch one phrasing. The first three runs went from 79% to 85% that way. A change goes in only when the score holds.
- Infrastructure43 of 45
- Public and social work41 of 45
- Environment40 of 45
- Hard casesVague asks, support questions43 of 50
- Work in a named placeA city, a ZIP code, a PLSS section10 of 12
- Heritage37 of 45
- My own requests2 of 3
Tephra on Claude Opus 5.5 at medium effort and the grader on Claude Sonnet 5.5. The whole run took 1,137 model calls and cost $18.29.
Ask the map a question
In Tephra you can ask for a view of the project’s map in plain words. Tephra reads the answers in the records and draws the view over the map: colors and sizes by any answer, a heat map, 3D columns, labels or only some records. It shows on your screen only. Nothing is saved, and Reset takes it away.
I built the lines after Tephra couldn’t do this one: “a dashed line and measurement in ft/in how far each point feature inside the excavation units are from the datum.” Now a view can draw lines from one record to the records a filter picks, each with its distance in meters and in feet and inches.
The model never draws on the map itself. It calls three tools I wrote: one reads the records, one shows a view and one clears it. MapLibre’s own validator checks every view before it draws.

Repos built for agents
Every repo is set up so an AI agent finds its way in a few reads instead of a search.
- A map in every repo. Each opens with a CLAUDE.md that says what lives where and which document decides what. One more above them maps all eight repos and says where to start.
- The agents keep the map current. A change another repo depends on updates its guide in the same commit. The guides changed 106 times in their first week. Claude was a coauthor on 105 of them.
- Tickets are plain files. Each is named in words and never by a number. Every commit in every repo starts with its ticket’s name. “What should I pick up?” is a question for Claude, not a board.
- One worktree per ticket. Each ticket gets its own copy of the repo and its own agent, many at once. The web app and the iPhone app run one shared set of test cases. They can’t drift apart.
Claude is a coauthor on every commit to the apps and writes Swift faster than I do. Neither of us knew the GPS could drop out during a phone call until I lost 4.2 km of road to one.
