# Nudge: I built my friend a productivity app that treats procrastination like a roguelike

Hacktoberfest Weekend Challenge: Build for a Friend Submission

This is my submission for the Hacktoberfest Weekend Challenge: Build
for a Friend.

What I (tried to) Built

My friend is an MBA student. Her problem isn't that she doesn't know
what she needs to do.

It's that the list of things she needs to do can become overwhelming
enough that starting any one of them feels difficult.

There are classes, assignments, presentations, deadlines, and a phone
full of apps designed to make ten minutes disappear.

So I started building Nudge.

Nudge is a productivity companion designed around one simple idea:

Don't solve the whole task. Just make the next step easier to
start.

The MVP combines:

• a Focus Shield for distracting apps,
• simple task creation,
• an AI task-slicing workflow,
• voice-note capture,
• XP for completed work,
• and earned screen-time unlocks.

The app is intentionally small. I wanted to build something that could
actually be used by one person rather than another giant productivity
dashboard.

Demo

Live demo: Under progress --- I wasn't able to finish the public
AI demo before the submission deadline.

I got the Android application running on an emulator and built the main
product loop, but I ran out of time while finishing the live Gemma
inference and public deployment.

For now, these are screenshots from the working Android build.

Today

The Today screen is deliberately simple: progress, current tasks, and
Focus Shield status.

The goal is to open Nudge and immediately understand what needs
attention without being overwhelmed by another complicated productivity
interface.

Tiny Steps

Tasks are displayed as small steps rather than one intimidating block of
work.

The task-slicing flow is designed to turn something like:

"Finish my final semester project."

into a handful of actions that are easier to begin.

Focus Shield

Focus Shield is the other half of the loop.

Instead of treating app blocking as punishment, Nudge connects focused
work with earned access to distracting apps.

Code

GitHub: Under progress --- I am uploading the current codebase.

The repository contains the Android application, Node/Express API,
native Android accessibility service, task-slicing logic, voice-note
integration, and the project setup needed to continue development.

How I Built It

The MVP stack is:

• React Native + Expo for the Android application
• Node.js + Express for the backend
• Gemma as the intended open-weight model for task decomposition
• ElevenLabs Scribe for voice transcription
• Render for the planned backend deployment
• Android's native accessibility capabilities for Focus Shield

I also explored Ollama for local Gemma inference during development.
The backend is structured around an OpenAI-compatible model endpoint, so
the model-serving layer can be swapped without rewriting the mobile
application.

The AI Task Slicer

The core AI idea is intentionally simple.

A user gives Nudge a large or overwhelming task:

"I need to finish my final semester project."

The intended flow is:

Large task
    ↓
Gemma
    ↓
3–5 tiny actions
    ↓
Nudge task cards
    ↓
Complete one small step
    ↓
Earn XP / unlocks

I implemented the backend integration path for this workflow, but I
wasn't able to get the live Gemma inference working reliably before the
submission deadline. The current build therefore falls back to a simple
task-splitting response when the model endpoint isn't available.

I am leaving that limitation visible rather than presenting the fallback
as completed AI inference.

Voice Capture

Nudge also includes a voice-note path intended to turn a spoken thought
into a task.

The intended flow is:

Voice note
    ↓
ElevenLabs Scribe
    ↓
Transcript
    ↓
Task slicer
    ↓
Tiny task

This was another part of the MVP I started wiring together, but the
submission-time build was not polished enough for me to call the
complete voice-to-task pipeline finished.

Focus Shield

The Android side includes a native accessibility service for Focus
Shield.

The app can maintain a list of distracting apps such as:

• Instagram
• YouTube
• TikTok

The product loop is:

Focus
  ↓
Complete tasks
  ↓
Earn XP
  ↓
Earn unlock time
  ↓
Use distracting apps intentionally

That is the part of the idea I wanted to make feel different from a
normal app blocker.

Why Does Open Innovation Matter?

A productivity app like this can eventually know quite a lot about its
user:

• what they need to do,
• what deadlines they have,
• how they plan their work,
• what they struggle to start,
• and potentially their voice notes and personal context.

I don't want the AI layer of that experience to depend completely on a
black-box model that I cannot change.

Using an open-weight model gives Nudge the possibility to:

• run inference locally,
• change the prompts and task-decomposition logic,
• swap models as better open models become available,
• experiment with different serving setups,
• and keep the AI workflow under the developer's control.

For this MVP, the important part is the architecture: the mobile app
talks to a backend, and the backend can talk to a separately hosted
open-weight model.

The final production architecture I had planned was:

                Nudge Android App
                       │
                       ▼
                 Render API
                  /       \
                 /         \
                ▼           ▼
       Application Data    Gemma
                            │
                            ▼
                     GPU / Local Inference

I didn't reach the final public deployment stage during the challenge
window, but this separation is already reflected in the project
structure.

What I Learned While Building It

The hardest part wasn't designing a productivity app.

It was keeping the scope small enough to finish.

I started with a much larger idea involving planners, calendars,
integrations, memory, and automation. The weekend challenge forced me to
strip that down to the part that actually mattered for my friend:

Make starting a difficult task feel smaller.

I also learned that getting an LLM into a project is only the beginning.

The generated output has to fit the application's data model, UI, and
user experience. A useful task decomposition needs to be:

• small,
• actionable,
• ordered,
• realistic,
• and short enough that the user doesn't feel like they have another task manager to manage.

The reward loop raised another design question: how do you make app
blocking feel motivating rather than punitive?

That led to the idea of earned unlocks: focused work creates progress,
and progress creates controlled access to distractions.

What I'm Building Next

Because I ran out of time before the final deployment, the next steps
are clear:

1. Finish reliable Gemma inference.
2. Replace the fallback task slicer with the live model response.
3. Finish and test the voice → transcript → task pipeline.
4. Test Focus Shield against real installed distracting apps.
5. Deploy the API publicly.
6. Publish a live web demo of the task slicer.
7. Test the complete focus → task → XP → unlock loop with my friend.

Handing It Over

The real test isn't whether the demo looks polished.

It's whether my friend actually opens Nudge when she has something
stressful to do.

If Nudge can turn:

"I have an enormous assignment and I don't know where to start"

into:

"Just open the brief."

and then make that first step feel worth doing, it has done what I
wanted.

I didn't get the whole product finished within the challenge window.

But I did get the core Android experience, the product loop, the native
Focus Shield foundation, and the AI integration structure into a working
project.

The rest is now a much smaller engineering problem than the original
idea.

My Agent Session

DevRelay / agent session: [OPTIONAL — ADD IF AVAILABLE]

AI assistance was used during development, but the product decisions
were driven by the real workflow I wanted to solve for my friend:
reducing the friction of starting, making progress visible, and turning
distraction access into an earned choice.

Prize Categories

Best Use of Gemma

Nudge is designed around Gemma as the open-weight model for turning
overwhelming tasks into small, structured actions.

The Gemma integration path is implemented in the backend, but live model
inference was not completed before the submission deadline. I am not
claiming the unfinished inference stage as completed.

Best Use of DigitalOcean

DigitalOcean was part of the planned deployment architecture for hosting
Gemma inference on a GPU.

This deployment was not completed before the deadline.

Best Use of MongoDB Atlas

MongoDB Atlas was considered for persistent task and application data,
but I intentionally removed it from the final MVP to keep the project
within the weekend scope.

Best Use of ElevenLabs

ElevenLabs Scribe was selected for the voice transcription layer. The
voice-to-task flow was started, but the complete production-ready
pipeline was not finished before submission.

Best Use of Render

Render was selected for the Node/Express backend deployment. The backend
is structured for deployment, but the public deployment was not
completed before the deadline.

Team Submissions

This is an individual submission.

Thanks for participating!

Nudge started with one friend and one problem:

Sometimes the hardest part of a huge task is doing the first five
minutes.

I didn't manage to ship every part of the original plan before the clock
ran out.

But I did build enough of the idea to see the product loop working on
Android, and enough of the architecture to continue from here.

That's what Nudge is for:

one small step.