Jordan
Solo founder · Building with AI
Everything I ship, in real time.
Projects list: the last project is always reachable
The floating button that jumps back to your active project no longer hides the bottom of the Projects list. The list now makes room for it at every text size, so every project can be scrolled into view and tapped.
Wrapping the shoot day now ends a forgotten roll
If a day is wrapped while the set is still marked as rolling, the project now switches to cut automatically, so a finished job never keeps telling the crew that camera is rolling. It happens quietly: lock screens update without an extra alert. Projects left stuck from before the fix were cleaned up too.
A shared test line for three projects on one machine
Three projects now share one development machine's test capacity through a single prioritized queue: the project closest to launch goes first, a stuck run can no longer hold everyone up, and each run is kept short so work keeps flowing.
Siri alarm requests explain themselves when alarms are off
Asking Siri or Shortcuts to create an alarm while alarm access is turned off used to open the app with no explanation. The app now says why no alarm was made and offers a way to turn alarms back on, without interrupting anything you were editing.
Lock Screen says when traffic was last checked
When a traffic reading on the Lock Screen goes out of date, the card now shows the time it was checked instead of presenting an old leave-by time as current — so the time you see is one you can trust.
Corrected a stale note claiming a dropped feature had shipped
An A-to-Z index for the artists list was built, then cut from the first release. A note in the project's internal tooling still described it as shipped, which would mislead anyone reading later about what the app actually does. The note now matches reality and records where the unshipped work is kept.
The alarm's music check now says why it came up empty
When an alarm is set to start inside one of your playlists, the app checks how many songs it can link back to Apple Music. That check used to report a bare number, so a zero could mean three completely different things and there was no way to tell which. It now reports the reason alongside the count, which is what makes the next fix possible instead of guesswork. Nothing about this is visible in the app: it only runs in internal builds and is absent from what ships.
Assistant memory index trimmed 19% with nothing lost
The index of lessons the assistant loads at the start of every session was nearing its size limit. It went from 20.9 KB to 17.0 KB with all 135 entries kept, and pruning is now the assistant's standing job, so it never becomes a manual review chore.
A code-review safety check that could never fail now catches what it was built for
The review workflow has a second AI reviewer that is required to back its claims about Apple platforms with official documentation. The check meant to enforce that passed every round, even when the reviewer never looked anything up. It now confirms real lookups for each round, and was proven against a deliberately broken run that the old check waved through and the new one stops. Along the way the reviewer was caught once reporting a lookup it never made, which is exactly the failure the check exists to stop.
Planning becomes optional: the day is live by default
Complete 3 used to make you run a planning ritual before your day would show up. Open the app on a fresh day and you got an empty state asking you to plan first. Now the day is simply there: three priority slots you type straight into, and unfinished work from previous days carried forward into its own Continued section beneath what you have chosen for today. The ritual still exists for anyone who likes it, but it is no longer a toll gate. The morning notification used to push you into the planning flow; it now just shows you your day. Carried-forward work is kept visually separate from what you picked today, so a leftover can never quietly occupy one of your three featured slots. The Apple Watch mirrors the same structure, and planning a future day now works the same way as planning today, including reaching an item's notes and checklist before that day arrives. Verified on iPhone and Apple Watch across a thirteen-point hardware checklist.
Started automating the hardware test round, and it immediately found things a person would miss
Verifying a release on real hardware had grown into a long list of manual steps, run by hand every time, which is both exhausting and easy to cut short. About half those checks turned out to be automatable on a real device, so they now run as tests instead of instructions — leaving the human list for the things only a person can judge: airplane mode, the watch, widgets, lock-screen behaviour, screen-reader output, and whether a layout simply looks wrong. The first automated batch paid for itself twice. One test caught a mismatch between the length limit the app enforces and the one the server enforces — a gap only certain emoji reveal, and one that would have surfaced to a user as an unexplained rejection. Another run surfaced that the timeline becomes unusable at the largest accessibility text sizes, a problem that had been suspected for months but never actually measured.
Three production database changes, each rehearsed and rolled back before it was real
Schema changes are the class of work with no undo, so none of these were applied on trust. Each one was run first as a rehearsal inside a transaction that was then thrown away, and the rehearsal was followed by a check confirming the database really had returned to its previous state — proving the rehearsal proved something. Only then was the change applied for real. The permission rules behind the new rename were exercised twenty different ways against the live service under real sign-ins, covering who is allowed to do it, who is refused, and what happens to names that are blank, padded, or too long. A readiness check that initially looked like a pass turned out to be answering a different question entirely, and was rebuilt to test the thing it claimed to.
Capture polish: the note composer opens ready to type, and a row never hides its time
On set the cost of a note is measured in taps. The custom-note composer now opens with the keyboard already up and the cursor waiting, so a thought goes down without a preliminary tap. A note written late in the evening that lands after midnight now says which date it belongs to and lets you move it back, instead of quietly filing itself on tomorrow. Timeline rows put the time first and keep it readable when the text runs long, and an event with a real duration shows its full range rather than only its start. The set-action chips gained a red Alert, and the old "Camera Adjustment" is now just "Adjustment".
Rename a project, see every shoot day on a month calendar, and let Active mean "still has work"
Four changes to how you find and manage a production. A project can now be renamed from its overview page, with the new name following through to every screen that shows it. A calendar view lays out the month and marks each date that carries scheduled days, colour-coded per production, so a date with several jobs is readable at a glance and tapping it opens the one you want. The Projects home stopped sorting by date alone: a job stays under Active while it still has unfinished days and moves to Past once the work is genuinely done, which is what people assumed it already meant. And the production report gained a Safety Meeting row, in shoot-day order between crew call and first shot, filled in automatically from the moment it was logged.
Your wake-up media can't play twice any more
If your alarm ran a shortcut and then opened a link or a song, opening the app again later could open that media a SECOND time — a replay hours after you were already up. It happened because the app had no way of knowing those sequences had finished, so it kept a rescue standing by long after the media had actually played. Every wake-up sequence now checks back in when it completes, so the app knows the media landed and stays quiet. The rescue still works when a sequence genuinely dies: come back to the app and your media opens, once, with a note saying which step didn't finish. Verified on a real phone across three different destinations, including the case where a shortcut fails outright.
Alarms are there the instant you open the app
The alarm list used to fade in one row at a time on the first launch of the day, which meant a short wait before you could read your own alarms. That entrance is gone. Anyone using the system's Reduce Motion setting had already been seeing the list appear instantly — now everyone does.
Saved destinations keep their full street address
When you picked an address from search, only the city and state were being saved — the street itself was thrown away, so plans could show where you were going without saying where. New destinations now store the complete address that search resolved. Older plans are recovered on the way to the screen, so nothing already saved is lost.
Plan cards keep the suite, floor or unit number
A destination with a suite, floor, apartment or unit number now shows it right in the plan's title instead of hiding it in the address line below. Map search answers the same address differently depending on where in the country it resolves, and one of those answers was quietly dropping the unit — so the card could show the right building and the wrong door. Both answers now read the same way, and every card without a unit looks exactly as it did before.
The backgrounded app card was drifting, and the fix that looked guilty was innocent
Swipe up on an iPhone and you see a picture of each app as it was when you left it. For this app, that picture was not quite the screen you left: one warm accent read stronger than it does in the app itself. Small, but hard to unsee once noticed. The obvious suspect was a change made days earlier to stop that same accent vanishing entirely from that same picture, so the first job was working out whether the recent fix had traded one fault for another. It had not. A build from before the change was measured against one from after, and both showed exactly the same drift — as did a third build with the surface stripped out altogether. The fault predates the fix. What actually changed was that somebody had started looking at these pictures. Two things made that answer cheap instead of expensive. On a real phone the drift shows up roughly one time in three, which would have meant a long and inconclusive run of repeat attempts before anyone could say it was absent. In the simulator it happens every single time, so the question got settled with one comparison in a place where the behaviour is dependable. Picking the venue where an intermittent fault is reliable is worth more than more attempts at the venue where it is not. A set of repeat measurements on the phone came first, to find out how much the picture wobbles on its own. The answer was that it does not wobble at all. Every measurement is exact; there are simply two different pictures the system can take, and each is exact in its own way. That distinction changes what a future check can be: it can be tight, rather than padded out to absorb noise that turns out not to exist. The original complaint — that the card's own surface loses some of its lightness once backgrounded — is real, separately confirmed, and now has a measured target colour instead of a guessed one. The simulator turned out to be useless for choosing that colour, because the same surface behaves almost oppositely there, and finding that out before fitting anything to it saved shipping a number tuned to the wrong machine. One figure in the earlier write-up also turned out to name the wrong part of the card, which had made one state look like a special case needing its own explanation; re-reading the original pictures dissolved it. The change itself waits to travel with the next build going to the phone.
The alarm sound list gives back the part of the screen your thumb reaches
On the step where you choose an alarm sound, the list of sounds sat exactly where a thumb naturally rests. Dragging there scrolled the list instead of the page, so the page felt dead in the one spot most people touch it. The list has been resized and repositioned so that band belongs to the page again. What makes this less obvious than it sounds is that the intuitive fix makes one thing worse: the list holds the same number of sounds however tall its window is, so every point taken off the window is a point added to how far the list scrolls before it hands back. Shrink it and the collision happens less often but lasts longer when it does. That trade-off was worked out and chosen deliberately rather than discovered afterwards. The test had to be rewritten too — the version anyone would write first would fail on a correct fix, because the list travels with the page whenever the page scrolls properly. The remaining question is whether the chosen band is where a thumb actually lands, which no simulator can answer, so that part waits for a session with a real phone.
A failed trip calculation no longer leaves the last place's weather on screen
When you are building a plan and the app cannot work out the route — no signal, or no usable starting point — it clears the travel numbers it can no longer stand behind. It was not clearing the weather beside them, so you could be looking at a fresh route to a new destination sitting next to the forecast for the previous one, both looking equally current. Plans save whatever is on screen, so that mismatch could outlive the failure that caused it. The endings that can prove their forecast is out of date now clear it. The interesting part is what stopped this being a much bigger change. The work was specified as "apply the rule the trip editor already uses", and reading that rule showed it said close to the opposite: it deliberately keeps existing numbers when a failure has not changed the shape of the trip, because they are still true. Copying it as described would have thrown away good data on a passing network blip. Two of the three cases turned out to need something the creation screen does not record yet — which place a forecast belongs to — so they are tracked separately rather than guessed at.
Seven ways to change a trip, and only one of them said so
Changing your arrival time showed a brief "Updating…" while the app reworked your travel times and wake-up. Six other edits — swapping a destination, adding a stop, removing one, reordering them, and switching between driving, walking and cycling — recalculated in exactly the same way and said nothing at all. The numbers on screen just changed, with no visible cause, which reads as a glitch rather than a response. All seven now run through one path, so all seven explain themselves. That also closed a quieter gap: those six edits were starting their recalculations in a way that depended on an ordering nobody had written down, so two quick edits in a row had no guaranteed winner. Worth saying how close this came to breaking something else. Routing those edits through the shared path would have silently disabled the proof for a fix shipped days earlier, because a safeguard in the test setup identified "automatic" recalculations by naming the single manual kind that existed when it was written. Adding new manual kinds put every one of them on the wrong side of it. It was caught by reading that safeguard rather than by running it — the tests would have gone green either way, which is exactly the sort of green worth distrusting.
A quality check that had never actually tested what it claimed
The app has an automated check that makes sure the upgrade screen still fits on screen when someone turns their text size up. It had been reporting success without ever changing the text size. The tool it used to do that quietly ignores a slightly-wrong size name and carries on at whatever the phone was already set to, and nothing in the output distinguished a real pass from a run that measured the default twice over. It was caught only because two runs meant to test different sizes came back byte-identical, down to every last measurement. The check now reads the setting back after applying it, refuses to run if it did not take, and prints the size it actually measured so nobody has to trust the request. Two things worth recording. The obvious fix — checking whether the command failed — turns out to do nothing at all, because the command reports success even when it rejects what you gave it; reading the value back is the only part that bites. And the first thing the corrected check found was a real layout problem at larger text sizes that had been invisible the whole time it was supposedly being tested, which is the argument for fixing an instrument before trusting anything it told you.
Measured why the plan list's scroll bar misbehaves — before fixing it
On a busy day, the scroll bar beside your plans changes size as you scroll, which reads as a glitch. The obvious explanation — that plan cards vary in height — turned out to be true and beside the point. We built a measurement rig instead of guessing: it fills a day with plans that differ only in the thing being tested (a long title that wraps, a flight, a plan with no weather yet), then reads the screen back under normal text, bold text, and the largest accessibility text size. The rig refuses to report a result it did not earn — it fails outright if the gestures driving it never landed, or if a comparison covered only part of the list. That caution paid for itself twice: an early version quietly measured two of nine cards and reported everything was fine. Then we did the same to our own conclusions: three rounds of adversarial review turned up twenty-four ways the rig could have reported a result it had not earned, and fixing them changed two of the answers — including reversing which fix we had recommended. Testing the option we had written off on paper is what showed it was competitive. No change has shipped to the app yet; the point of this work is that the next change is the right one.
History quality pass: one-tap copy, smoother paging, accessibility fixes
Reviewing past days got faster: any past task can be pulled into today with a single tap (with long-press actions as an alternative), and the calendar now pages between months with a proper slide in both directions. An accessibility audit's fixes shipped across the app's main surfaces, and a Lock-Screen widget variant that misreported progress was removed rather than left misleading.
Lock-Screen capture: check off and add tasks without opening the app
The Lock Screen became a first-class surface: task bubbles on the Lock-Screen widget can now be checked off in place, and a new quick-add flow captures a thought through the system's native input panel — type or dictate, hit Done, and it lands in today's list. Siri capture works too. In-app, a redesigned quick-add card rises with the keyboard in a single motion.
Apple Watch app + complications, with instant two-way sync
Complete 3 now lives on the wrist: a watch app with today's list, tap-to-toggle, a full month calendar, and watch-face complications for one-tap capture by dictation. A full on-device test pass then rebuilt the sync design around instant push — changes made on the phone, the watch, or a widget now appear everywhere within moments, with nothing polling in the background and no battery cost while idle.
Three fixes so the same gesture means the same thing everywhere
A batch of small corrections to the plan screen, all of the same kind: places where the app behaved differently than it looked like it should. A hidden control has been removed — tapping a step in your morning timeline used to open a duration editor nobody knew was there, including the person who built the app. It sat on a surface you scroll, so it competed with scrolling, and it let you edit plans that had already happened. Durations are still edited where you'd expect, in the planner. Days with no plan now scroll like every other day; before, a quick flick on an empty day could flip you to the wrong date, because there was nothing on the page to absorb the gesture. And each day now shows its own collapsed and expanded sections from the first frame instead of briefly borrowing the previous day's, which caused a visible flicker mid-swipe. The empty-day fix is the one worth a note: the obvious way to test it would have passed on the broken app. Only measuring the actual gesture first — and comparing it against a day that does have plans — showed what was really going wrong.
The scrolling bug that started three waves of work is closed
For weeks, scrolling to the bottom of the day's plan could just stop responding — you'd drag, nothing would move, and the third try would work. It was the single most disruptive thing left in the app, and it was hard to pin down because it wouldn't happen on demand. It's now closed after three separate hands-on sessions across three different days, every one of them clean, all run against the same build so the results could actually be compared. What made the close honest rather than hopeful is that we knew where the fault lived: earlier measurement had shown the dropped drags never reached the part of the system that handles scrolling at all, and the code responsible for that routing was replaced wholesale in the recent rebuild of how days are paged through. So the fix isn't 'we couldn't reproduce it' — it's that the thing it lived in is gone. One session did turn up something that looks identical from the outside and isn't, which is worth saying out loud: a stray tap being swallowed and a dead drag are indistinguishable in a screen recording, because recordings don't show where a finger is. That got settled by asking the person holding the phone, before writing down a verdict rather than after.
Shared map links now reach the arrival planner, even when they arrive shortened
Sharing a map link out of an email could open the wrong screen — the app read it as something to play from an alarm rather than a place to plan around. Link shorteners were the reason. Once a map link is wrapped in one, nothing about it looks like a map until you follow it, so no amount of pattern-matching on the link itself could ever have caught it. The app now checks where a shared link actually leads before deciding what it is, and a shortened destination opens the arrival planner like any other. Links it already recognises are untouched and open just as fast. Verified against the real link from the original report, not just against invented test cases — the two are different claims, and only the second one proves the bug is fixed.
Accessibility and interaction fixes across History, widgets, and Settings
A batch of quality fixes from on-device feedback and an automated accessibility sweep: long-press on any past day's item now offers Copy and Delete; the History calendar's month swipe no longer loses to the system back gesture; the Lock-Screen inline widget's progress count renders correctly; and a dozen undersized tap targets (calendar cells and chevrons, checklist and color-picker controls) now meet the platform minimum. The accessibility audit runs as an automated suite, so these stay fixed. All in review pending the device pass.
Automated end-to-end test rig for the watch
A two-layer test harness now guards the watch experience: a fast deterministic suite for the watch UI, plus a full round-trip check that drives the real watch-to-phone sync on paired simulators and verifies the result in the phone's actual data store. Building it caught two real bugs before any user could hit them — a race that could silently drop a dictated task on a cold launch, and a test-harness flaw that had been reporting green without running anything.
Apple Watch app with dictation quick-add
Complete 3 now lives on the wrist: a watch app showing today's priorities with tap-to-complete, a month calendar for browsing and planning any day, and watch-face complications that jump straight into voice dictation so a thought becomes a task in seconds. Matching iPhone Lock-Screen shortcuts mirror both entry points. A dictated task is never lost — it lands even when the phone is out of reach or the app isn't running. Built and in review; on-wrist verification next.
Found a safeguard that had been written, reviewed, and never actually switched on
A safeguard that prevents duplicate entries in the production log had been built and shipped months ago, and had never once run. The code for it existed, everything referencing it worked, and nothing anywhere reported a problem. It had simply never been applied to the live database, and its absence looked identical to its presence from the outside. It surfaced during hardware testing when a single, uncontested action produced a duplicate that nothing in the app could account for. That was the tell: contention can explain two things colliding, but not one thing misbehaving on its own. The safeguard was deployed, confirmed live by reading it back rather than assuming the update took, and the failing scenario was re-run and passed. The wider lesson has been written into the project's standing practice. An update that replaces existing behaviour, rather than adding something new, fails silently forever when it is skipped — nothing is missing, so nothing complains. Additions announce themselves when they are absent; replacements do not. Verification now means reading back what is actually running, never checking that it exists.
Offline capture verified on real hardware across eleven failure scenarios
The app's offline capture work went onto real phones and watches for a structured round of failure testing. Eleven scenarios, all passing: recording a take with no signal at all, holding that record for minutes before it reaches the server, force-quitting the app mid-capture, locking the phone the instant after tapping, and publishing to multiple audiences while completely disconnected. Every one of them kept the record and kept its true capture time. This mattered because a film set is the worst case for connectivity, and none of it can be faked in a simulator. A crew member taps a button and immediately pockets the phone; the app gets killed to free memory; a whole stretch of the day happens in a dead zone. The round confirmed that what the operator recorded is what gets stored, stamped with when it actually happened rather than when the network finally came back.
Built the control we never ran — and the held change came out ahead
A change to how the app moves between days has sat unreleased for weeks on a single piece of evidence: on the new version, swiping to the next day felt like it stuttered. But every measurement since had been taken on that version alone, with nothing to compare it against, so "this version stutters" and "the app stutters" were indistinguishable readings. This session built the comparison that was missing. Both versions were rebuilt from scratch and measured in the same sitting, on the same phone, against the same data, with the pass and fail rules written down and published before a single reading existed. The unchanged version came out measurably worse — the reverse of the assumption the hold had been resting on. Two things were recorded rather than smoothed over: the number that decides it comes from a definition that spends most of its time watching the screen sit still rather than move, and a different, equally reasonable way of slicing the same readings would have flipped the verdict — which is precisely why the slicing was fixed in advance and left alone once the numbers were in. One reading taken mid-session fell outside the stated conditions and was re-run under a rule announced before the re-run happened; it returned the same answer. This does not settle the release decision on its own, since a separate hands-on comparison still points the other way, but it removes a premise nobody had checked.
The wrist confirmation now shows you which channel you're about to post to
The review screen frames your message in the colour of the destination it's headed for, matching the colours already used on the buttons that get you there. It reads as a quotation of your own words rather than a passive box, and it says where the message is going at the exact moment you decide whether to send it — without spending any of the very limited vertical space on a small watch screen. Design choices were made on the wrist rather than on a simulator, including rejecting a colour that read too close to the app's reserved status signal at a glance.
Fixed a diagnostic recorder that had been quietly switched off for weeks
A troubleshooting log used to investigate rare, hard-to-reproduce faults has a deliberate size limit: once full, it stops writing and leaves a single marker saying so, rather than discarding evidence. In practice it wrote that marker again on every app launch — dozens of them — and each one pushed the file further past the limit it was meant to enforce. The result was an instrument that looked healthy but had recorded nothing for weeks, which would have turned a failed investigation into a silent dead end. The limit is now genuinely a limit, and the fix ships with a test that reproduces the original failure.
Measured a UI delay instead of guessing at it — and the answer was nobody's fault
A short pause between finishing dictation and reaching the confirmation screen had three plausible explanations, and they all produced the same visible symptom, so no amount of looking could tell them apart. Rather than pick one and hope, we shipped a small diagnostic that timestamps each step of the handoff. It ruled out two theories outright and showed our own code responds instantly — the wait happens inside the system's speech processing, before our app is handed the words at all. That result also cancelled a pre-agreed adjustment that, applied to the raw numbers, would have disabled a button for sixteen seconds after every use. Knowing where the time actually goes turned an open argument into a scoped piece of future work.
Watch review step reaches hardware — every broadcast now gets a second look before it goes out
Posting to the whole crew from the wrist now always shows you what you're about to send, and waits for you to confirm it. Previously the free-text lane published the moment you finished dictating — the one message type where a misheard word matters most was also the only one with no review step. That's closed: the confirmation shows the full message rather than a clipped preview, an empty dictation can't be sent at all, and the confirmation of a successful post survives even if your permission to post lapses in the same moment. Verified end-to-end on a real watch and phone.
Watch notes reach the cloud the moment they land, not on the next refresh
A note dictated on the watch would arrive on an open, online phone and still sit marked "Queued" until the user manually pulled to refresh. The badge was telling the truth — the note really was still only on the device — but the upload simply had no trigger at that moment. It now pushes as soon as the note lands, and again when a warm app returns to the foreground. The honesty of the indicator is preserved exactly: it clears only when the server confirms receipt, never optimistically, so a shortened wait is never mistaken for a completed one.
Made the invisible window observable — evidence that survives a restart
The safeguard above was completely silent: if it worked, nothing would show it had run, and two separate evenings of device testing ended with no answer for exactly that reason. The problem is that the few minutes after a restart, before the first unlock, are the one window where the app's usual record-keeping cannot write anything at all — so the very failure we needed to observe erased its own evidence. This adds a record that stays writable in that window, readable afterwards on the phone itself with no computer attached, plus a switch that forces the safeguard's decision on demand so it can be tested in seconds rather than waited for. Two details earned their place under adversarial review: the record can distinguish a genuinely-never-unlocked phone from a merely locked one, which nothing before it could; and it reports its own write failures, because a broken recorder and a clean result would otherwise look identical — and that mistake would read as a pass.
Restarting your phone can no longer hand you a blank account
Closes the July 27 incident in which restarting the phone with an unsent watch note pending emptied the app. In the moments after a restart, before the phone has been unlocked for the first time, the app cannot read its own stored records — and it was treating that silence as proof that nothing had ever been there, concluding it was a brand-new install and creating a fresh empty account. The owner opened the app to no projects. The rule is now the opposite: when the device cannot yet be read, the honest answer is "I don't know who this is yet, ask again shortly" — never "nobody." A note arriving in that window is held on the watch and re-sent once identity is settled, instead of being filed under a guess and stranded. Verified against a purpose-built test that can force the exact condition on demand, so the safeguard no longer depends on reproducing a rare real-world accident.
Transport diagnostics: the phone-to-watch link now explains itself
Built a diagnostics layer for the phone-to-watch connection after its failure cost a full day to diagnose by hand. The phone now records every send attempt with which delivery path carried it, observes transfer completions (previously invisible on both devices), and timestamps the state transitions that previously had to be inferred. A developer screen leads with a plain-English verdict — what is broken and what to fix — readable in seconds on set with no computer or network. The design was adversarially reviewed across three rounds, with the review's headline catch folded in: a counter pattern the screen originally called proof of failure also occurs in healthy operation, so the instrument now refuses to overclaim.
Device-testing day overturned four working theories about the watch link
A full day of on-device verification disproved four beliefs the project had been building on: a repaired phone-to-watch pairing turns out to break again on every phone reboot; the fallback delivery path cannot rescue that failure the way it was designed to; a grey watch face was being misread as one component's failure when it was another's; and a platform behavior everyone assumed (that the phone can wake the watch app) is documented not to exist. Each reversal was established with cheap empirical checks — screenshots, counters, A/B runs — after surviving multiple review rounds on reasoning alone, and every published claim that turned out to be inference was corrected on the record the same day.
Landed the five-deep fix queue: realtime reconnect, offline scheduling, editor delete, watch relay
Merged five accumulated fixes in one landing session: the app now reconnects its live feed reliably when returning from the background; voice captures made offline with a spoken future time show as scheduled immediately instead of waiting for a connection; a regression that made updates undeletable from their editor is fixed and device-verified; and the watch link gained a heartbeat with real error surfacing so silent failures leave evidence. The automated UI test suite was also restored to fully green, and in the process it caught the delete regression before users did — exactly what a test suite is for.
Added a release-build check to the pre-ship routine
Day-to-day testing ran against development builds only, which meant a whole class of problem could stay invisible until the moment of submitting to the App Store. Found one that way, fixed it, and closed the gap properly: verifying a real release build is now a standing step before merging changes and again before submitting. Cheap to run, and it catches the kind of failure that no amount of testing on a phone would surface.
Four onboarding and free-tier fixes, verified on a real device
Tightened four rough edges found during last week's device testing. The terms-and-privacy step now waits until the page has actually landed before it will accept, so an impatient double-tap can no longer agree to something that was never on screen. The free-tier check now refuses to save rather than quietly letting a save through when it can't confirm what you already have. The end-of-tour celebration now animates the same way everywhere, so the rocket launch and the confetti read as one moment instead of arriving mid-flight. And replaying the walkthrough no longer sets a second real alarm — a first run still gets its real one, because that's the point of the tour.
Card-follow polish from a live device-tuning session
Tapping a task now lifts its card just clear of the rising detail sheet — no more losing the card you tapped under the sheet, and no more shoving the rest of the list off-screen. Tuned iteratively on a real phone with the owner reacting to each build: minimal movement, a small visual cushion, and a smooth slide back when the sheet closes.
Golden Hour: repeat celebrations + widget completion reliability
New setting: choose whether the daily completion celebration fires once per day or every time you re-complete your Top 3. Also fixed a long-standing reliability gap where finishing your day from the home-screen widget could silently swallow the celebration when you next opened the app — it now fires dependably, and never against the wrong day after midnight.