My friend has a very consistent productivity strategy.
“I'll do it after lunch.”
Then:
“Okay, after dinner.”
“I'll definitely do it tomorrow.”
And somehow, tomorrow always wins.
When I saw the Build for a Friend challenge, I knew I didn't want to build another generic chatbot.
And I definitely didn't want to build a to-do list with an “AI” button slapped onto it.
I wanted to build something around a problem I'd actually seen.
So I built Tomorrow.
An AI companion for one very specific problem:
What if the hardest part isn't finishing the task but starting it?
Tomorrow is an AI powered anti-procrastination companion.
It doesn't try to manage your entire life.
It doesn't give you a 47 step productivity plan.
And it definitely doesn't respond to every problem with:
“You got this!”
Instead, it asks:
“What's actually stopping you?”
You tell Tomorrow what you're avoiding.
It tries to understand why you're stuck, breaks the task into something smaller, picks one realistic next step and helps you start.
For example:
“I need to finish my React assignment but I don't know where to start.”
A typical productivity app might give you a checklist.
Tomorrow might say:
Don't finish the assignment yet.
Open the project.
Create the form component.
That's it. Give it 15 minutes.
Because sometimes the problem isn't the task.
It's the size of the first step.
The entire experience revolves around a simple loop:
┌──────────────────┐
│ What are you │
│ avoiding? │
└────────┬─────────┘
↓
┌──────────────────┐
│ Understand the │
│ blocker │
└────────┬─────────┘
↓
┌──────────────────┐
│ Break the task │
│ into smaller │
│ actions │
└────────┬─────────┘
↓
┌──────────────────┐
│ Pick ONE next │
│ action │
└────────┬─────────┘
↓
┌──────────────────┐
│ Focus session │
└────────┬─────────┘
↓
┌──────────────────┐
│ Check in │
└────────┬─────────┘
↓
┌─────┴─────┐
↓ ↓
Done Stuck
↓ ↓
Next step Reassess
│ │
└─────┬─────┘
↓
Start again
The interesting part isn't really the timer.
It's the feedback loop.
Tomorrow doesn't assume the first plan worked.
If the user gets stuck that becomes new information.
If the user finishes it moves forward.
If the task turns out to be bigger than expected it breaks it down again.
The goal isn't perfect planning.
The goal is progress.
This project started with a pretty simple observation.
Procrastination can look like this:
Big Task
↓
"I'll do it later"
↓
Guilt
↓
Avoidance
↓
Task feels bigger
↓
"Tomorrow."
↓
Repeat
Tomorrow tries to interrupt that loop:
Big Task
↓
Tell Tomorrow
↓
Find the blocker
↓
Make it smaller
↓
Start for 15 min
↓
Progress
Not:
“Become a productivity machine.”
Just:
“Let's make starting a little easier.”
I didn't want the AI to generate motivational quotes and call that intelligence.
Its job is much more specific.
The user explains what they're avoiding.
“I need to apply for internships but there are so many websites and I don't know where to begin.”
The obvious response would be:
“You're procrastinating.”
Cool.
Not very helpful.
The actual problem might be overwhelm.
So Tomorrow tries to identify the blocker behind the task.
Different blockers need different responses.
Some examples:
If the problem is:
“I don't know where to start.”
Give them a starting point.
If it's:
“This feels huge.”
Shrink the task.
“I'm scared I'll do it badly.”
The next step might simply be creating a rough first draft.
The AI isn't only asking:
“What should you do?”
It's also asking:
“Why aren't you doing it?”
Let's say the user enters:
Apply for internships
That's not really one task.
It's a tiny project pretending to be a task. 😭
Tomorrow can turn it into:
Open your resume.
Pick one internship.
Read only the requirements.
Decide whether you want to apply.
The goal isn't to solve the entire journey in one response.
It's to find the smallest useful action.
This is where the idea becomes more than a chatbot.
Imagine the user says:
“I need to apply for internships but I'm overwhelmed and keep putting it off.”
Tomorrow first tries to understand the blocker.
Task:
Apply for internships
Possible blocker:
Overwhelm
Problem:
The task contains too many hidden steps.
Next action:
Open your resume.
Focus:
15 minutes
So instead of telling the user to spend the next three hours applying everywhere, Tomorrow gives them one thing:
Now imagine the user comes back and says:
“I didn't do it.”
That's not treated as failure.
It's information.
Tomorrow can ask:
“What got in the way?”
The user says:
“I opened LinkedIn and started scrolling.”
Now the next response can change.
Original task
↓
Apply for internships
↓
Blocker
Overwhelm
↓
First action
Open resume
↓
User got distracted
↓
Reassess
↓
Smaller action
Open the resume file only
The AI isn't simply repeating:
“Try again!”
It's using the failed attempt to decide what to do next.
That's the part I cared about.
A normal chatbot might work like:
User
↓
Question
↓
AI response
↓
Conversation ends
Tomorrow is designed more like:
User
↓
Task
↓
Blocker
↓
Next action
↓
Task state
↓
Focus session
↓
User check-in
↓
Updated context
↓
New action
↺
The response isn't just displayed as text.
It influences the next state of the task.
That's what turns the AI from a chat box into part of the workflow.
I wanted the application to know where the user actually is instead of treating every message as a completely new conversation.
The basic state flow is:
NEW
↓
BLOCKED
↓
BROKEN_DOWN
↓
STARTED
↓
COMPLETED
And when things don't go according to plan:
STARTED
↓
STUCK
↓
REASSESS
↓
NEW SMALLER STEP
That STUCK → REASSESS loop is important.
Because real people don't follow plans perfectly.
And honestly, if they did I probably wouldn't have built this. 😂
The system needs to treat a failed attempt as context not as a dead end.
The plan didn't work. So let's figure out why.
I kept the architecture intentionally simple:
User Input
↓
React UI
↓
Task + Conversation State
↓
Context / Prompt Builder
↓
Open-Weight AI Model
↓
Blocker + Next Action
↓
Task State Update
↓
Focus Session
↓
User Check-In
↓
Updated Context
↺
The frontend handles the interaction.
The application state keeps track of where the user is.
The context layer gives the model the information it needs about the current task and previous interaction.
The model then helps determine things like:
What is the user trying to do?
↓
What is blocking them?
↓
How can the task be reduced?
↓
What is ONE useful next action?
The important part is what happens after the model responds.
The result is used to update the task workflow rather than simply being shown as another chat message.
At a high level, the AI interaction can be thought of as:
User message
↓
Extract task
↓
Identify blocker
↓
Estimate task complexity
↓
Generate smaller actions
↓
Select one next action
↓
Return structured guidance
↓
Update task state
Input:
"I need to finish my React project but I'm overwhelmed."
↓
Task:
Finish React project
Blocker:
Overwhelm
↓
Breakdown:
- Identify missing feature
- Open relevant component
- Create component
- Connect component
- Test it
↓
Selected next action:
Open the project and identify the missing feature.
↓
State:
STARTED
This is important because I don't want the model to produce a giant wall of productivity advice.
I want the output to be useful to the application's workflow.
This was one of the biggest design decisions in the project.
If the AI were removed the app would lose the part that:
The model isn't decorating the interface.
It's helping determine what happens next.
That makes the open-weight AI part of the core product logic rather than an extra feature added to the UI.
This is where the project became more interesting to me.
At first, the idea was simply:
“I'll use an AI model to help break down tasks.”
But then I thought about the kind of information Tomorrow could eventually handle:
That's a lot of personal context.
And I didn't want the long-term version of Tomorrow to require sending all of that to a closed AI provider.
So I designed the project around an open-weight AI model and a local-friendly architecture.
The open model isn't there just because the challenge asks for open AI.
It changes what the product can eventually become.
A productivity assistant that knows your unfinished work and personal struggles is dealing with information that can feel much more sensitive than an ordinary chatbot conversation.
That's why local inference is an especially interesting direction for this type of product.
Imagine telling your productivity assistant:
“I've been avoiding job applications because I'm scared I'll get rejected.”
That's much more personal than:
“Give me a pasta recipe.”
😂
For something like Tomorrow, privacy matters.
A long-term version could work like:
User
│
▼
Personal Context
│
▼
Local AI Model
│
▼
Next Best Action
│
▼
User
The idea is:
Your personal productivity context shouldn't automatically have to leave your device just to get useful AI assistance.
And because the model is open-weight, the project isn't permanently tied to one proprietary AI provider.
The interesting part of building an AI product isn't always getting the model to respond.
It's getting the response to be useful.
One problem I had to think about was task size.
If the user says:
“I need to finish my project.”
A technically correct response could be:
“Break the project into smaller tasks.”
But that's not actionable.
The user is still staring at the same giant project.
So the system needs to go one level deeper:
"Finish my project"
↓
"What part?"
↓
"Build the frontend"
↓
"What part of the frontend?"
↓
"Create the login page"
↓
"What's the smallest action?"
↓
"Open the project and create Login.jsx"
That's the difference between advice and an actionable next step.
Another challenge is what happens when the user doesn't complete that step.
A normal chatbot might simply suggest the same thing again.
Tomorrow needs to treat that as information.
That feedback is what makes the workflow adaptive.
This is probably the most important part of the challenge for me.
I could have started with:
“What cool AI application should I build?”
Instead, I started with:
“What does my friend actually struggle with?”
The answer was pretty obvious.
They didn't need another productivity lecture.
They didn't need a complicated dashboard.
They needed help getting past:
“I'll do it tomorrow.”
So I built around that.
And starting with a person instead of a technology changed the product.
It made me remove things that sounded cool but didn't really solve the problem.
No giant productivity dashboard.
No unnecessary streak system.
No pretending that waking up at 5 AM will magically fix everything.
What are you avoiding?
Why?
What's the smallest thing you can do next?
The biggest thing I learned from this project was:
AI doesn't have to solve the entire problem.
Sometimes it just needs to solve the next 10 minutes.
That changed how I thought about the product.
I initially imagined features like:
But then I asked myself:
Would any of this actually help my friend start?
Not necessarily.
So I kept stripping things back.
One problem.
One person.
One next step.
And honestly, I think the product got better every time I removed something.
There are a few directions I'd love to explore.
Instead of typing:
“I'm avoiding my assignment…”
the user could just say it.
That could make the interaction feel much more natural.
Over time, Tomorrow could notice recurring patterns.
“You tend to postpone tasks when the first step isn't clear.”
Or:
“You usually get started when the task is broken into smaller actions.”
That could make the assistant more personalized without requiring the user to explain everything from scratch every time.
The long-term goal is to make the entire experience work locally:
UI
↓
Local Data
↓
Local AI
↓
Personalized Guidance
No cloud AI dependency for the core experience.
Just a private AI companion running on your own machine.
The project was built and tested through an agent-assisted development workflow as part of the challenge.
The agent workflow helped iterate on the application logic, task flow and user experience while keeping the core idea focused on one question:
What's the smallest useful action the user can take next?
My friend didn't need another app telling them:
“Wake up at 5 AM.”
They didn't need a 12-step morning routine.
They didn't need another productivity guru.
They needed something that could say:
“Forget the whole thing for a second. What's the smallest thing you can do right now?”
That's what I wanted Tomorrow to become.
Not an AI that manages your entire life.
Not another to-do list.
Not another chatbot that gives you motivational paragraphs and disappears.
Just a small, private, open-AI companion that helps you take the first step.
Because sometimes the hardest part of getting something done...
is simply starting.