ChoreDivider

The same chore isn't the same work for two people. ChoreDivider asks each of you privately, then deals the day so minutes stay even and nobody gets what they dread.

Comment

Inspiration

In May 2026 my wife Marie and I moved into our house after sixteen months of building and gutting it. We were exhausted. Both of us wanted to just lie on the couch and not move.

That is when the needling started. "Are you doing the dishes?" "I did the laundry, what did you do?" It sounded like banter, but it wasn't. We were both exhausted, we both felt we were carrying more than our share, and we had no way to tell. We had no system at all. Everything ran on shouting across the room and on gut feeling, and our gut feelings disagreed about what "fair" meant.

Then there was the house itself. Freshly moved in means a hundred half-finished things: baseboards, lamps that still hang from bare wires, and a basement we skipped entirely so we could move in at all. Every one of those was a low-level argument waiting to happen.

The moment that turned this into an app was a conversation about cooking. I told Marie I would rather renovate the basement twice than cook dinner every night. She said the exact opposite: she would take cooking over anything house-related any day, sixteen months of construction had cured her of that for life. So we tried something. We each rated, on our own, how draining every chore in the house felt to us. The results surprised us both. I rated cooking, meal planning and the weekly grocery run far worse than she did. She rated everything with a screwdriver far worse than me.

Every chore app we could find asks "how hard is this chore?" once, for everyone. Our answer was that the question is wrong. The same chore is not the same amount of work for two different people. So I built an app that asks each person separately, keeps their answers private until everyone has answered, and then splits the work in a way that is fair in minutes and cheap in dread.

We have used it everyday since. We don't argue about chores anymore. It has turned into a small competition about who clears their list first, so we can meet on the couch in the evening with nothing hanging over us.

What it does

ChoreDivider is a native iOS app for a household of two or more people.

  • Everyone rates every chore for themselves, from 1 (barely notice it) to 10 (dread it). Ratings stay sealed until everyone in the household has rated, so nobody anchors on anyone else's number.
  • The app deals the day. Each morning it assigns the chores that are due so that the last 14 days come out even in minutes, and then, within that, it keeps everybody away from the chores they hate most.
  • A rolling 14-day ledger instead of a debt counter. One ring per person on the Today screen; rings of equal length mean the last two weeks came out even. A quiet week pulls more work back to that person until the rings match again, and then it ages out. Nobody carries a grudge from March.
  • Projects are the one-off jobs a house accumulates: the basement, the baseboards, the lamps. Each person ranks them in a quick pairwise duel by their own priorities, and the app merges the personal orders round-robin into one household queue, so nobody's priorities silently win.
  • No account, no server. Data lives in the household's own iCloud and syncs with CloudKit sharing. A person without a phone, a child or a partner on Android, is a real member: you hand them your phone and the app acts as them until they hand it back.
  • One purchase unlocks the whole household. The free tier covers a couple with up to four members and ten active chores. The Household Pass, sold through RevenueCat, is written onto the shared household record, so one person paying means everyone is premium. The most common complaint about every competitor we looked at is "I pay, but my partner doesn't have premium." We wanted to never hear that.

How I built it

  • Stack: SwiftUI, Core Data with NSPersistentCloudKitContainer for sync and sharing, RevenueCat for purchases. No backend of my own. XcodeGen generates the project. The only two dependencies are the RevenueCat SDK in the app and swift-snapshot-testing in the test target.
  • The domain layer is pure Swift with no SwiftUI, Core Data or CloudKit imports, so the fairness math is unit-tested in isolation. Across the targets there are about a thousand test functions, including snapshot baselines for every screen in both languages.
  • The solver is an exact lexicographic branch-and-bound, written in Swift because no MIP solver I evaluated had a viable iOS build. It optimizes a ladder of objectives in strict priority order:
  1. minimize the spread of load between members, with the ledger's last 14 days as a starting balance,
  2. minimize the worst single day's spread (whole-week solves only),
  3. minimize total personal exhaustion, using each member's own rating as their cost,
  4. then exhaustion spread and chore-count spread as tie-breakers.

A real household solves in a few milliseconds. The solver carries a one-second safety valve and falls back to a greedy longest-processing-time split for pathological inputs, and that fallback has to produce a fair result on its own.

  • Timeline: the first commit is from May 3rd, 2 days after we moved in. By late May the app worked, and I stopped. I picked it back up on August 11th with a written UX spec whose first line was, in my own words, that the app "reads as AI slop". Since then it has been a sprint: roughly 320 commits in six weeks, 64 TestFlight builds, four data-model versions, and full German localization (about a thousand strings) alongside English.
  • Built with AI, openly. I am a developer by trade, and I paired with Claude and Cursor for most of the code; the commit history says so on every commit. The fairness model, the product decisions and the design direction are mine, and every screen went through real people before it shipped.

Challenges

  • I rebuilt the entire UI three times. First a playful, RPG-flavoured theme with levels and a design picker. Then a flat, warm "Clay" system in August. Then, in September, "Instrument": true black, one flat colour per person, big tabular numerals, and three concentric rings whose only job is to be the same length. Each rebuild threw away the previous one's screens, and each one taught me something the previous one hid. Levels and points were cut for good in round two; the fair split is the whole reward.
  • Real testers found the real problems. A first-time user ticks off the first chore, does exactly the right thing, and the app answers with the only red headline it has: "Drifting apart". The plan for the day was fair, but the screen only showed the ledger of what was already done. The most common action in our own household, "Marie did this, on my phone", took five taps through a hidden mode. The same privacy explanation appeared three times on one screen. None of that was visible to me; all of it was visible within an hour to someone who did not know the app.
  • Fairness has to survive missing data. A household where one person has no phone, a chore saved with zero minutes, a member who has rated only two chores, a sealed rating that must not leak through the split. Every one of those has a rule in the domain layer now, and every rule has a test.
  • A household-wide purchase on top of a per-account SDK. RevenueCat entitlements belong to an App Store account, but the promise is "one purchase, everyone premium". The app writes the grant onto the CloudKit-synced household record, with a policy that must never shorten or clear a grant this account did not make. That policy is pure Swift and tested branch by branch, because getting it wrong silently strips premium from a whole family.

What I learned

  • Get strangers on it early. With only two months of build time I still waited too long for feedback, and the tests with people who are not close to me were the most useful hours of the project. Weeks of redesign could have been days if I had put a TestFlight build in front of someone in August instead of September.
  • Copy is a feature. Half of the last two weeks were words, not code: one privacy sentence instead of three, "how draining is this for you" instead of anything cleverer, five phrases for ten numbers because a rating is a feeling, not a measurement.
  • Design is a constraint, not a coat of paint. The version I am proud of is the one with the fewest colours, two fonts, and one metaphor. Everything I removed made the fairness more visible.
  • A dark-only app can be warm. The ink is cream, not white, and the headlines are set in a serif. It reads like print on an instrument face, and it stopped feeling cold the day that landed.

Accomplishments I'm proud of

  • The app has been running our household since May, and it works: two tired people who used to needle each other now race to clear their lists.
  • An exact fairness optimizer that runs on-device in milliseconds, with no server and no account, and a free tier that covers our own use case completely.
  • A design I am proud to show. It took three attempts and it is not finished, it never will be, but it is the first version where testers laughed at the app out of delight rather than confusion.
  • Shipped on time for the Shipaton, from "this looks like AI slop" to App Store submission in five weeks.

What's next

Not features. Distribution. The app is where I want it for a 1.0; what I do not have yet is feedback from people I have never met. The next months go into App Store optimization, getting the story in front of couples and families, and folding what real strangers say into the app. Android is on the list only once retention proves the idea holds for households that are not mine.

Built With

Share this project:

Updates

Submission history