Selected Work
From spec to App Store in two weeks: an AI-native planner that turns messy input into a living, timeline-aware plan
Overview
Moti is an AI-native iOS planner, designed, built, and shipped end to end. Say it or type it, and it comes back as work already sorted by project, waiting for your yes.
Role
0→1 Product Designer & Builder
Timeline
2 Weeks · May–June 2026
Tools
SwiftUI · Foundation Models · Gemini · Claude · Codex
Output
Shipped on the App Store · SLM + LLM Integrated
Highlights
Type the sentence the way you would say it, lowercase and unpunctuated. What comes back is not a task in a list. It is the work pulled out of that sentence, each piece carrying the project Moti thinks it belongs to, and not one of them filed.
Drawing bars on a timeline is the easy part. The hard part is deciding that a review is an appointment, a case study is work with a duration, and a launch is a deadline. That understanding layer is the thing I got wrong twice before it behaved like this.
Projects
Every project with its active count, its next date, and how far it has run
Add to Timeline
Lowercase, unpunctuated, exactly as you would say it, and Submit is the only next step
The problem wasn’t planning. It was understanding.
The Problem
This is not built for people who lack a system. It is built for the moment a system is already full, when what fails is not capture, and not the list that shows the result.
It is the step between the two. Something has to read what arrived, work out what it is for and when it is due, and set it against everything already owed. That step has no owner, so the input stays exactly as it landed, and the cost only shows up at the far end.
Overwhelming Inputs
Thoughts, deadlines, and half-formed ideas, all landing on the same day.
Fragmented Thinking
Nothing reads them together, so each one stays a loose end.
Unclear Action
The list is full, and the next move is still a guess.
Three stages, one failure, and only the middle one is worth fixing. Make capture easier and the pile arrives faster. Act on the list and you are sorting work that nothing has understood.
Competitive Analysis
Five tools answer that middle step five different ways. I looked at each one for a single thing: what happens to a sentence after you type it.
Todoist takes the sentence down. Motion schedules it for you. Sunsama asks for the discipline to plan the day deliberately. Notion holds it in any structure, after you have built one. ChatGPT reasons about it and never sees your timeline.
Five different destinations, and five different things still left for you to do once the sentence arrives.
Todoist
Great for capture
Doesn’t plan for you
Motion
AI scheduling
Can feel rigid
Sunsama
Intentional daily planning
Requires discipline
Notion
Flexible and powerful
Heavy setup
ChatGPT
Flexible thinking
Not timeline-aware
The gap is not capture. It is the step after: understanding what arrived, and keeping it moving.
Principles
Each of these frustrations names something one of those five tools does to you. I turned every one into a rule Moti had to obey.
A rule that only names a virtue can be satisfied by anything, so each of them also names the thing it rules out.
The frustration
The rule it produced
“Entering tasks is so annoying.”
Natural Input
You say the sentence you were already thinking. Moti does the structuring.
Ruled out: A structured entry form as the way in.
“It’s hard to change plans when things change.”
Adaptive Timelines
When something changes, the plan you already have shifts to absorb it.
Ruled out: Regenerating the plan from scratch.
“I spend more time organizing than doing.”
Living Plans
The sorting happens when the work is captured, not in a session you set aside for it.
Ruled out: Sorting the work yourself before the timeline is usable.
“I end up with more tasks, not more clarity.”
Momentum Tracking
Work shows how far along it is, and the timeline shows where the pace is heading.
Ruled out: Progress measured by how many tasks are left.
“AI suggestions don’t get my timeline or real-world constraints.”
Context-Aware Planning
The timeline, the open projects and the commitments already made go in before anything is planned.
Ruled out: A suggestion made without the timeline in front of it.
“I just want a plan that adapts to me, not the other way around.”
Human-Centered Planning
Moti proposes. You answer with Add to Timeline, Refine or Dismiss, and one of the three is no.
Ruled out: Anything landing on the timeline without a yes.
Every principle is a refusal. That is what kept Moti from becoming another place to put things.
Final Design
The principles above are refusals, and refusals are cheap until a product has to keep them. So here is the loop itself, one sentence in and a plan out. Each step is there because the one before it left something undecided.
Seven Steps, One Loop
Each step picks up what the one before it left undecided.
Say It
Ask One Thing
Propose, Do Not Commit
It Waits for You
Work Has a Shape
Check In
It Says When You Are Drifting
A plan you can refuse is a plan you can trust.
Nothing in this loop asks you to file anything. When Moti is unsure it asks instead of guessing, and when it proposes, one of the three answers is no. Everything else is its job.
Intelligence
The loop above contains three jobs with nothing in common. A due date has to be exactly right. Parsing has to be instant. Planning has to reason. One model doing all three is one model doing two of them badly.
Three Tiers, Three Jobs
Rule-Based
Dates, checkpoints and timeline math. Computed, never inferred, because a date that is usually right is a bug you cannot see.
Foundational Model · SLM
Reads the sentence while you are still looking at the screen. Understanding only. It stops before planning.
LLM
Weighs a launch against a lease renewal. Judgment across projects, and the one job worth the wait.
The tiers are not a hedge. Understanding is the step nobody owned, and it is the one job that needed a model of its own.
Build Journey
All three tiers were in the spec before any code existed, with how Moti should behave, how you talk to it, and what it looks like. What no spec could settle was how far to trust the model. The three versions below are that question, answered with real builds.
Rule-Based Prototype
Testing the core interaction loop
What Broke
Trust broke under complexity.
Learning
The interaction model worked. The intelligence layer had to evolve.
Foundational Model for Understanding
Why Evolve
Temporal blindness, context loss, over-rigid parsing.
Learning
Understanding fidelity is the bottleneck.
Constraining the Understanding Layer
Stance
Not autonomous planning. Reliable understanding.
Shipped
TestFlight with real feedback, then the App Store.
What kept changing was never the interface. It was how much of the thinking belonged to the machine.
What It Proved
Three versions later, the bet held: the failure sits in understanding, not in scheduling.
A Complete Loop, Shipped End to End
Capture, clarify, propose, plan, check in. Built with Claude and Codex, live on the App Store.
Understanding Beat Autonomy
Trust broke in V0. The model got one job, understanding, and the user kept Add, Refine and Dismiss.
A Spec Settles Behavior, Not Trust
Behavior and interaction were fixed before any code. How far to trust the model took three versions.
V0 asked the machine to plan, and trust broke. What shipped asks it to understand, and leaves the planning as a proposal you answer.
