Inspiration
Every student runs the semester on three guesses. How long will the problem set take, when will I begin it, and how well will I concentrate once I do? The calendar holds the plan and the gradebook holds the verdict, and between the two lies the work itself, which nobody measures. Such measurement as does exist is performed on students and seldom for them. Universities buy analytics that flag who is at risk, and the student whose habits produced the data never sees a line of it.
We wanted the instrument to belong to the person it describes. Two requirements followed from that wish. It had to observe without being asked, because a tracker that needs tending is abandoned by midterms. It also had to keep what it saw on the machine where it was seen, because a study tool that reports to anyone else has stopped being a tool and become a supervisor.
What it does
Tempo is a native Mac app that watches how you work and distils the day into three numbers. Readiness is what you have to spend, read from how late last night ran and how heavy yesterday was. Focus is how the day is going, measured as work done against a target and weighted by the quality of each session. Pace is the number that changes behaviour. For every open assignment it forecasts the hours that remain, fits them into the time your calendar leaves free, and names the latest moment at which you can begin and still finish.
That forecast never consults your own estimate. It is the median of how long your finished work of the same kind actually took, drawn from the course in question where the record is deep enough and from all your courses where it is not.
Each night the app relearns you. It writes a profile in plain Markdown that records how many days out you tend to start, how much of the work lands in the final twenty-four hours, and which site most often pulls you away. It also tests patterns against data it has not yet seen and promotes one to a finding only after it has held twice. Three coaches of differing patience sit in the notch of the display and speak up when work turns to drift while a deadline is near.
How we built it
The product is two halves joined by one protocol. StudyCore is thirteen thousand lines of Swift that depend on nothing beyond Foundation. It holds every formula, every importer, the nightly run and the findings engine, and it passes 378 tests on Linux. The app is a SwiftUI shell of about the same size that formats and draws what the core returns and computes nothing of its own. Between them stands TempoStore, which has two implementations. The first is a synthetic semester worked out to the last session, against which every screen was built. The second is the real store backed by files, which replaced the first at integration without a single screen having to change.
Capture writes one sample every five seconds, and a sample is nothing more than the front app, the window title, the host of the tab, a count of input events and a hash of the network. String rules classify most samples against the student's Canvas assignments. Samples then fold into sessions, and browser history folds in the same way, which is how a fresh install recovered 108 sessions from 38 days of one teammate's past.
The coaches are signed distance fields ray-marched on the CPU in plain Foundation, so the code that drew the sheet we approved on Linux is the same code that draws them on the Mac.
Challenges we ran into
Half of the app was written on a machine that cannot compile it. One of us works on Linux, where SwiftUI does not exist, so the only compiler for the interface was a macOS runner several minutes away. We made that loop bearable by having it render every screen to an image on each push, and then we closed it properly. An agent on the Mac ran the app through a written checklist and reported to a GitHub issue, and the Linux side answered with fixes. Since those reports would describe a real student's coursework, we built a diagnostic that prints counts and statuses and never a name, which let a failure be discussed in full without disclosing what anyone was working on.
Real data proved less forgiving than the fixture. Chrome holds a lock on its own history file, and Safari refuses access to its history until the user grants Full Disk Access. Many assignments in a real Canvas account carry no due date at all, because the deadlines live in another system, and without a date there can be no Pace, so we gave the student a way to supply one. A pause of under half an hour was at one point read as a night's sleep.
The hardest restraint was conceptual. A language model will cheerfully produce a score or declare a pattern, and it would have been quicker to let it. We kept every number in deterministic code and allowed the model nothing but words.
Accomplishments that we're proud of
The live loop works on real data. On a Mac that the code was never written on, a student opened an assignment, the session appeared against it, Focus climbed from zero to eighteen, and a detour to a distraction showed in red on the timeline. Pace then named a start time for a real assignment, drawn from that student's own history and from nobody's guess.
We are prouder still of what the app declines to do. It takes no screenshots and keeps no typed text. It keeps a window title only for the day it was seen, after which each stretch of work is known by its site or app and the assignment it served. Its findings engine would sooner show nothing than show something untested, and on real data, with one weekend of live history behind it, nothing is exactly what it shows. We believe that to be the correct output.
The coaches, finally, have a material. They are solids of coloured glass that light enters, crosses and leaves, computed without a graphics card, and a custom coach is a true blend of its parents' geometry and of the light their glass transmits.
What we learned
A fixture is a specification that can be run. Building the synthetic semester first forced every formula to agree with every other before a single screen existed, and when the real store arrived the screens had nothing to relearn. The same discipline exposed our weakest assumptions quickly, since real accounts broke them within the hour.
We learned that privacy is an engineering constraint whose consequences reach everywhere, down to the manner in which a bug is reported. We also learned where a model belongs in a product that makes claims about a person, which is after the arithmetic and never in place of it.
What's next for Tempo
Time is the missing ingredient. Findings need weeks of live sessions before the first can be confirmed, so the next milestone is simply a semester of use. Alongside it we want direct connections to the systems where deadlines actually live, a companion on the phone so that hours spent away from the Mac stop being a blank, and sleep taken from a wearable in place of the activity gap that stands in for it now. The profile is already a folder of files the student owns. We would like it to become something they carry from one semester into the next, and eventually out of school altogether.
Built With
- accessibility-api
- appkit
- applescript
- canvas-lms-api
- claude
- claude-code
- codex
- eventkit
- github-actions
- keychain
- macos
- sqlite
- swift
- swift-package-manager
- swiftui
- xcodegen
