I Built BURST for My Father — Because Knowing What to Do Isn't Always Enough
Turn Intention Into Action.
devchallenge #hacktoberfest #ai #opensource #productivity
I Built This for My Father
My father is always working on something.
There is always work to finish, something to figure out, an idea to think about, or another responsibility waiting.
And while thinking about what I could build for the Hacktoberfest Build for a Friend challenge, I kept coming back to something I had noticed in him.
Sometimes, the problem isn't knowing what needs to be done.
You can know exactly what you need to do.
You can even want to do it.
And still...
you don't start.
Or you start and lose momentum.
Or something else suddenly becomes more interesting.
Or the task sits there for another day.
And then another.
I don't think that's laziness.
And I don't think another motivational quote fixes it.
It made me wonder:
What if the problem isn't the person? What if the way we're asking them to work needs to change?
That question became BURST.
Turn Intention Into Action.
⚡ Meet BURST
BURST is an adaptive execution system that helps people turn intention into action.
It's designed for anyone who struggles with things like:
- getting started
- procrastinating
- feeling overwhelmed by large tasks
- maintaining focus
- figuring out where to begin
- repeatedly postponing the same task
- losing momentum
- jumping from one project to another
These are also challenges that can occur alongside executive-function difficulties, including those experienced by people with ADHD.
But BURST isn't an ADHD diagnostic or treatment tool.
It doesn't try to tell someone what's "wrong" with them.
Instead, it asks a much simpler question:
What can we change to make the next action easier?
Why I Didn't Build Another To-Do List
We've already built thousands of ways to write:
"Finish project."
And thousands of ways to remind someone that they haven't done it.
But a reminder doesn't necessarily create action.
Imagine I give my father a task:
Finish the project.
That's technically a task.
But it's not necessarily an action.
BURST tries to turn it into something that can actually be started.
For example:
⚡ 10-MINUTE BURST
MISSION
Write the first three points
of the project proposal.
You don't need to finish it.
Just start here.
[ BURST IT ]
Suddenly the task has a boundary.
It's small.
It's concrete.
And there is a finish line.
The Timer Is Not the Point
At first glance, BURST might look like another focus timer.
It isn't.
The timer is just the first step.
The interesting part starts when the Burst doesn't go as planned.
Imagine BURST gives you:
10 minutes — Write the introduction.
And you save it.
Later, it gives you the same thing.
You save it again.
A normal productivity app might just keep reminding you.
BURST should eventually recognize:
This approach isn't working.
And change the strategy.
Instead of:
Write the introduction.
It might give you:
⚡ 5-MINUTE BURST
Don't write the introduction.
Find one introduction you like.
Read it.
Write down three things
you notice about it.
[ BURST IT ]
The goal didn't change.
The intervention did.
That's the idea behind BURST.
🧠 What Happens When You Save a Burst?
I didn't want to create a system that asks:
"Why are you procrastinating?"
and then gives you five psychological categories to choose from.
People aren't that simple.
So BURST can simply ask:
What's making you save this for later?
And let the person say whatever they want.
Maybe:
"I don't know where to start."
Maybe:
"I'm exhausted."
Maybe:
"This feels pointless."
Maybe:
"I actually need to understand Question 4 first."
Or maybe:
"I just don't want to do this right now."
They can also skip it.
That response isn't treated as a confession.
It's context.
And context can help the system decide what to try next.
🔄 BURST Learns From What Happens
The core idea looks like this:
GOAL
↓
AI PLANNER
↓
BURST
↓
USER ACTION
↓
OUTCOME
↓
MEMORY
↓
PATTERN
↓
ADAPT
↓
NEXT BURST
This is the part that makes BURST different from a static productivity tool.
The AI isn't only generating tasks.
It can eventually reason over the history of those tasks.
For example:
Shorter Bursts seem to work better for this type of task.
Or:
Large, ambiguous tasks are repeatedly being postponed.
Or:
This particular project keeps getting stuck at the same stage.
Or:
The user makes more progress when the first step involves gathering information instead of producing something.
The system isn't trying to psychoanalyze someone.
It's trying to learn:
What actually helps this person move forward?
The Rule: Don't Blame the User. Change the Strategy.
This became one of the most important design principles of BURST.
If a Burst isn't completed, I don't want the application screaming:
FAILED
or:
YOU MISSED YOUR GOAL
That doesn't help.
Instead:
The Burst ended.
And then:
What should we do next?
Maybe the task needs to be smaller.
Maybe the user needs more context.
Maybe the task itself is unclear.
Maybe a different approach would work.
Maybe they simply need to stop for now.
The system should adapt before it judges.
🚀 Then I Realized This Applies to More Than Everyday Tasks
While designing BURST around execution, I realized the exact same problem appears when people build things.
Especially businesses.
I've seen this cycle:
IDEA
↓
EXCITEMENT
↓
BUILD
↓
NO IMMEDIATE TRACTION
↓
"I GUESS THIS ISN'T WORKING"
↓
ABANDON
↓
NEW IDEA
↓
REPEAT
The answer isn't:
"Never give up."
That's terrible advice.
Sometimes you absolutely should stop.
The problem is stopping — or continuing — without enough evidence.
So the larger BURST vision includes a Business Coach layer.
🧭 Business Coach + Burst Engine
The Business Coach answers:
What should we learn next?
The Burst Engine answers:
What should I do right now?
Together:
BUSINESS COACH
↓
HYPOTHESIS
↓
EXPERIMENT
↓
BURST ENGINE
↓
ACTION
↓
EVIDENCE
↓
NEXT DECISION
Instead of telling someone:
"Build your MVP."
BURST could turn that into:
⚡ Find 3 potential users.
Or:
⚡ Write one customer interview question.
Or:
⚡ Talk to one person who has this problem.
Now you're not just "working on your startup."
You're learning something.
🧪 From Idea to Evidence
The business journey inside BURST is designed around:
IDEA
↓
PROBLEM
↓
CUSTOMER
↓
HYPOTHESIS
↓
EXPERIMENT
↓
EVIDENCE
↓
CONTINUE / CHANGE DIRECTION
That distinction matters.
BURST isn't designed to tell people:
"Keep going."
And it isn't designed to tell them:
"Quit."
It asks:
What evidence do we have?
Maybe the problem isn't valuable.
Maybe the wrong people are being asked.
Maybe the product isn't solving the problem correctly.
Maybe the pitch is unclear.
Or maybe the idea is actually working and needs more time.
The next Burst should help answer that question.
🏗️ Under the Hood
The larger BURST architecture looks like this:
BURST
│
┌────────────┴────────────┐
│ │
EXECUTION ENGINE BUSINESS COACH
"GET IT DONE" "WHAT NEXT?"
│ │
└────────────┬────────────┘
↓
ADAPTIVE MEMORY
│
┌────────────┼────────────┐
↓ ↓ ↓
PATTERNS OUTCOMES INTERVENTIONS
│
↓
NEXT BURST
The eventual AI pipeline is:
Goal
↓
Planner
↓
Burst Generator
↓
User Action
↓
Outcome
↓
Memory Extractor
↓
Pattern Detection
↓
Intervention Engine
↓
Next Burst
So AI isn't sitting beside the product as a chatbot.
AI is part of the product's feedback loop.
💻 What I've Built for the Challenge
For the challenge, I deliberately started with the smallest version of the core experience.
The current deployed prototype includes:
- A focused BURST dashboard
- Goal and progress tracking
- A next-mission concept
- A dedicated Burst screen
- A working countdown timer
- Start/end Burst interactions
- Execution statistics
- A dark, distraction-conscious interface
The current vertical slice is:
GOAL
↓
MISSION
↓
BURST
↓
ACTION
The adaptive layer is the next step:
ACTION
↓
OUTCOME
↓
MEMORY
↓
ADAPTATION
↓
NEXT BURST
I wanted to get the central interaction right before adding layers of features that don't actually help the user execute.
🛠️ Technology
The current prototype is built with:
- React
- TypeScript
- Vite
The larger architecture is designed to add:
- FastAPI
- PostgreSQL
- Open-source AI
The AI layer is intended to work through structured application logic rather than simply sending every interaction through a chat interface.
For example, a Burst could eventually be represented as:
{
"mission": "Find one example introduction",
"duration": 5,
"reason": "Previous writing attempts were postponed",
"strategy": "Reduce ambiguity"
}
That makes it possible for the application to actually act on AI output rather than simply display it.
🎥 Try BURST
Live Demo:
https://burst-blond.vercel.app
The current demo shows the core execution interaction:
Goal
↓
Mission
↓
Start Burst
↓
Work
↓
End Burst
The next version will extend that into:
Create Goal
↓
Generate Mission
↓
Start Burst
↓
Work
↓
Complete / Save
↓
Explain What Happened
↓
Adapt
↓
Next Burst
And eventually, for Business Mode:
Project
↓
Hypothesis
↓
Experiment
↓
Evidence
↓
Next Decision
🌍 Why Open Innovation Matters
For me, open innovation isn't just about putting a repository on GitHub.
It's about being able to experiment with what AI can actually do inside a product.
BURST needs AI to do more than generate text.
It needs to eventually:
- interpret free-form feedback
- reason over previous outcomes
- detect repeated execution patterns
- generate structured actions
- change intervention strategies
- help design business experiments
- reason from evidence
Open-source AI makes it possible to explore those ideas with more transparency and control.
And because BURST is open source, the interesting part isn't just the final interface.
It's the reasoning and feedback loop underneath it.
❤️ Why I Built It
I started BURST because I wanted to build something useful for my father.
But while building it, I realized the problem was much bigger than one person.
There are students staring at assignments they don't know how to start.
People with ideas who can't turn them into projects.
Founders who keep switching directions because they don't know whether something is actually failing.
People who can make a perfect plan and still struggle with the first step.
People who need a smaller starting point.
People who need a different strategy.
And people who simply need something that helps them figure out the next move.
That's what I want BURST to become.
Not a system that tells people to try harder.
A system that asks:
"What happened?"
And then:
"Okay. What should we try next?"
⚡ Final Thought
Most productivity tools ask:
What do you need to get done?
BURST asks:
What should you do next — and what should change if that doesn't work?
Because sometimes turning intention into action isn't about more discipline.
Sometimes the task is too big.
Sometimes the first step is unclear.
Sometimes the strategy is wrong.
And sometimes you need to stop trying to force the same solution.
BURST — Turn Intention Into Action.
Built for my father.
Designed for anyone who struggles to get the thing done.
Built for the Hacktoberfest Weekend Challenge: Build for a Friend.
Top comments (0)