Daywell has an iOS app, an Android app and a website. I am one person, and each of the three is built by its own Claude Code session. That works until a parent opens the app on her phone and the web on her laptop and they disagree.
This post is about the times mine disagreed, and the mechanism I built after each so it would not happen a second time. The short version: agents do not drift because they are careless. They drift because nothing made the three copies one thing.
How do I keep iOS and Android apps in sync when AI agents build them?
Make the words and the rules live in one shared file that every app reads, and make a check fail when an app types its own copy.
My contract is one sentence in the root instruction file: prompts, limits, section order, and every word a parent reads must be identical on iOS, Android and Web. Change it everywhere in one commit, or nowhere. A contract written as a sentence is a wish, though. Here is the first time I saw it fail.
On 1 October 2026, the iOS session left a note in the code: this sentence already shipped on web, do not re-word it. The web app did not contain that sentence at all. The claim had been passed on twice before anyone opened both files and compared them. Nobody lied. Each session trusted the note above it, and the note was a memory, not a source.
A note in the code is a memory, not a source. Open both files.
That day I decided every word on all three apps should come from one shared JSON. Every string now has an id in that file. Each app is tested byte for byte against it. And the rule that came out of it is the one I trust most: a session may not type a sentence that is not in the file. If a word is missing, it stops and asks the owner of the file.
Why do AI coding agents copy values instead of sharing them?
Because copying is the fastest way to finish the task in front of them, and each session only sees its own folder.
I found out how far that went on 5 October. A tuning setting, the AI model identifiers and the household role names had each been typed separately on all three clients. Nothing was visibly wrong yet. But the first time anyone changed one of those values, two apps could have moved and the third stayed behind, and I would have found out from a parent.
My reaction was to write a rule: every shared value has exactly one source, a file in a fixtures folder, and nobody types a copy. I then learned that a test beside the rule is still too late. If you test that two copies match, you only catch the drift after somebody has already made a second copy. So the check I built looks at the code, not the values. A script reads the app source and the server functions, finds any quoted literal that exists in a declared fixture, and fails the push unless the copy is on a short, commented allow list. Old copies sit on a baseline list that may only get shorter.
The fixtures folder holds many small files, and they come in kinds: closed vocabularies (a list of allowed reasons or categories), the words themselves, limits, the shape of requests and responses, and the rules for what a push notification says. One spec per notification, generated for each app, instead of three sessions writing three versions of the same notification.
The rule it produced: a shared value is born in the fixture, and a typed copy is a defect even when a test happens to match it.
Every incident ended with a mechanism, not a reminder.
What happens when one app fixes a bug and the others do not?
The others fall behind, unless the exact wording of the fix travels with it.
On 2 November, a review of the iOS build found that the "1 card was updated with new info" line was counting too generously. It counted an email that only reworded a summary. The iOS session fixed it so that a card counts as updated only when the newer email added or moved something the parent can actually see. The same day, the Android and web sessions each shipped the same stricter count, as two separate commits that each cite the iOS change. That is the process working. It only worked because the iOS commit carried the exact wording of the new rule, so the other two sessions did not have to guess.
What I took from it: the exact text of a change travels with the change. A session that finds a difference files the delta for the other apps, with the wording, before it pushes. And a screen change cannot leave my machine unless the spec file for that screen changed in the same push. A script on push looks at which platform folders the push touches. If it touches a screen file and no commit in the push also touches the shared screen spec, the push is refused. Skipping the check is possible, but it leaves a mark, so it is a decision and never a habit.
The spec travels with the screen change, or the push does not leave.
Can two different pieces of code say the same thing differently?
Yes, even inside one product. Two notification routes are the example.
On 6 November the Android notification for an event reply was missing a field the iOS one carried. Same event, same parent, one phone got less. The fix was small, but the lesson was in how it was done: the server now builds the Android message with the same code it uses for the iPhone one, so the two delivery routes cannot drift again. That is the move I look for in every fix now. Do not patch the second copy. Make the second copy stop existing.
How do I stop a bug from coming back in the other apps?
Write a test for the instance, a test for its neighbours, and a check that fails if any future place skips the fix.
On 11 November, the main branch went red. A set of rows in the Android settings, for a test-build developer screen, were shipping with typed titles instead of the shared words. The commit that fixed it says exactly what it did: one test for the seven rows that broke, and one test for the theme, every key in that family marked for Android must ship byte for byte. The check that catches a typed copy is the same one described above. So the fix covers the class: the next developer row, in any app, is already guarded.
Same day, I stopped waiting for a parent to find the next difference and wrote a spec for a walker that opens every clickable thing on every page in iOS, Android, mobile web and desktop web, and compares them. It records differences. It reports and never blocks, because I want to rule on each difference myself and fix them in one batch per app. The spec and its shared files were written on 11 November, the day I am writing this, so I cannot tell you yet what it finds.
What I would tell another founder
If you do one thing: do not rely on a test that two copies match. Add a check that stops the second copy from existing.
- Give each app its own agent session and its own folder, and have each file a task for the others instead of editing their code.
- Put every word and every shared value in a file under version control. One source. The apps read it or are generated from it.
- Never accept "it already shipped on the other app" from a note. Open both files.
- Do not rely on a test that two copies match. Add a check that stops the second copy from existing.
- Make the screen spec part of the push. If the code changed and the spec did not, refuse.
- When you fix a bug in one app, put the exact new wording in the commit so the other sessions can port it without guessing.
- Every fix gets two tests: the bug itself and its neighbours.
- Keep the checks cheap enough that the agents do not want to skip them.
Daywell (getdaywell.com) reads a parent's school and daycare email and turns it into a short list of what to have ready, and when.



Top comments (0)