Inspiration
I wanted a timer that matched how I actually try to work: focus on one thing for a deliberate block, stop when the block ends, take a real break, and then begin again. Existing productivity products often turn this into another system to maintain—with tasks, projects, streaks, accounts, or dashboards. I wanted the opposite: a quiet time instrument that would make me more efficient without becoming more work.
The Apple Watch was essential to that idea. A focus timer should remain useful when the phone is not beside me, while still behaving like the same timer when I return to the iPhone.
What it does
Focus Time Log is a native iPhone and independent Apple Watch focus timer with two intentional modes: Focus and Rest.
- Choose Focus or Rest, select a duration, and start in seconds.
- Use a 60-minute Focus and 10-minute Rest rhythm by default, while retaining flexible five-minute duration steps.
- See one canonical active timer across the iPhone app, Apple Watch, widgets, Lock Screen, Dynamic Island, complications, and Control Center.
- Stop a Focus session early and save the time that was actually completed.
- Record Focus time exactly once while intentionally excluding Rest from history.
- Review Focus history by hour for the current day or by day for the current week.
- Keep the Watch useful independently and reconcile devices after temporary disconnection.
- Keep data private: there is no account, advertising, social layer, third-party analytics, or custom backend.
The product deliberately has no pause button, task manager, project system, calendar, streaks, or leaderboard. It does one job: hold the boundary around focused work and real rest, then provide an honest record of the focused time.
How we built it
Focus Time Log uses Swift and SwiftUI in one Xcode project with dedicated iPhone, Apple Watch, iPhone widget, Watch widget, integration-test, and UI-test targets.
The code is separated into local modules:
- FocusCore owns timer state, commands, duration rules, conflict resolution, and history aggregation.
- FocusData uses SwiftData for persistence, an exact-once command journal, and CloudKit-compatible records.
- FocusIntents exposes context-aware Start Focus, Start Rest, End Timer, and Toggle Timer actions.
- FocusUI provides shared visual tokens and components across apps and system surfaces.
The timer stores timestamps rather than persisting a decrementing counter. Every surface derives its countdown from the same scheduled end time. App Groups share state with local extensions, WatchConnectivity provides immediate peer updates, and private CloudKit provides durable convergence. Immutable revisions and deterministic conflict resolution prevent an old offline timer from replacing newer state. A Focus session reuses the timer ID, allowing repeated completion events to remain idempotent instead of double-counting history.
AlarmKit is used where available for persistent system alarms, with notification fallback for older systems and disconnected Watch behavior. WidgetKit, App Intents, and Live Activities expose the active timer beyond the main apps.
How Codex and GPT-5.6 were used
Codex was a product and engineering partner throughout the project rather than a one-off code generator.
We used it to narrow the scope, choose an Apple-native architecture, plan the iPhone/Watch relationship, implement the app and system extensions, debug behavior, design tests, verify builds, prepare deployment workflows, and maintain the technical documentation.
Visual development also happened with Codex. Before committing to interface directions, we generated multiple visual concepts and icon options, compared them, and refined the strongest direction. After implementation, screenshots of real builds were used as feedback. Early versions had centering, spacing, truncation, and hierarchy problems; concrete screenshot review helped turn those vague reactions into targeted code changes and reusable design-system constraints.
GPT-5.6 was the primary reasoning and implementation model inside Codex. Its value was focus: once we agreed on a narrow product contract, it could work autonomously across architecture, Swift code, tests, and documentation, then respond precisely to follow-up feedback. This made it possible to produce an iPhone and Apple Watch product—with widgets, system controls, persistence, cross-device synchronization, and tests—in days rather than the much longer path I would have faced while learning unfamiliar parts of Swift and watchOS alone.
GPT-5.6 is used in the development workflow, not as a runtime dependency. Focus Time Log does not send a user's timer history to a language model.
Challenges we faced
The main product challenge was keeping a simple timer genuinely simple while supporting many Apple surfaces. The iPhone, Watch, widgets, Live Activity, and Control Center could not become separate timers with slightly different truth. The timestamp state machine, idempotent commands, deterministic conflict resolution, and exact-once Focus persistence were the engineering answer.
The most visible iteration challenge was UI quality. Early builds sometimes looked amateur despite being functionally correct: content was not centered, text could escape its intended space, and visual hierarchy varied between screens. We addressed this by reviewing screenshots, giving direct feedback about what was wrong, and moving the corrections into a shared FocusUI package with reusable layout, typography, motion, color, and component rules.
Accomplishments that we're proud of
The independent Apple Watch app is the part I am most proud of. I had never built a Watch app before, and it now starts, runs, and ends Focus or Rest timers while sharing a coherent product with the iPhone app.
I am also proud that the simplicity is supported by serious engineering: timestamp-derived countdowns, exact-once history, offline reconciliation, private CloudKit synchronization, App Intents, system widgets, complications, persistent alerts, accessibility adaptations, and automated tests—all without introducing an account or custom server.
What we learned
The clearest lesson was that Codex becomes dramatically more capable when the problem is scoped precisely. The breakthrough was not asking it to “make a productivity app.” It was deciding what the product must do, what it must never become, and what one source of truth should mean across Apple devices. With that contract in place, GPT-5.6 could act like a dedicated senior engineering partner: discuss decisions, implement them, test the result, and keep iterating until the details were right.
What's next
The next step is the App Store release path: final production identifiers, privacy and support pages, signed iPhone/Watch testing, CloudKit production-schema verification, TestFlight, and the remaining device-level alert and synchronization matrix. The V1 scope will stay intentionally narrow while those production gates are completed.
Log in or sign up for Devpost to join the conversation.