Study Continuity Tool
Thread helps adult learners pick up exactly where they left off after a study session is interrupted. It captures notes during a session, makes sense of them automatically, and hands them back the moment the learner returns.
Turning "where was I?" into "oh right, here."
Paste the prototype
This was a solo project focused on making education easier for remote learners. Every step (Research, Design, Coding and Testing) was carried out carefully, using real data and real users, not a guesswork and was assessed by a PHD mentor.
Turns out, "I forgot what I was doing" is a documented cognitive event, not a personal failing. So before sketching a single screen, the question became: what does the science actually say about mental interruption? and how we can use previous researches in understanding and solve this problem?
‣The real problem:
Busy adult learners drop off at noticeably higher rates than other learners, and it was not because they lose interest. They drop off because every interruption costs them time and mental energy to rebuild what they were doing ,and that invisible cost is what quietly kills momentum.
‣Three things stuck with me from the literature:
Interruptions don't just pause focus, they fade it.
— Altmann & Trafton, 2002
Leaving yourself a clue beats trusting your memory, every time.
— Iqbal et al., 2019
The right external system doesn't just save information, it makes the comeback easier.
— Risko & Gilbert, 2016
‣What's already out there:
Notion remembers your notes. Trello remembers your tasks. Nothing remembers your train of thought, the half-formed idea, the question you were chewing on right before you got pulled away. That's the gap Thread lives in.
‣ Design principles derived from research:
Three rules came out of all that reading, and every screen had to answer to them
1- Store what the learner is thinking so they don't have to carry it.
2- Surface it the moment they come back, so it's recognized, not rebuilt.
3- Make capturing a thought feel like part of studying not an extra work on top of it.
Three rounds. Three very different reactions from real people. Here's how the idea evolved each time someone actually used it.
‣Iteration 1: laying the foundation:
The first version (it was even called something else "Check Point") nailed the core idea before anything else:
a dashboard card showing exactly what you finished, what's next, and what you were still wondering about.
The study screen had four ways to capture a thought: Note, Question, Key idea, Record
Ending a session meant four steps: confirm, checklist, last thought, next move.
‣ Iteration 2: what 12 people actually said:
A usability survey went out to 12 active learners. Most people found their way around easily. But the end-of-session checklist was a problem, only 4 out of 12 said they'd actually complete it every time. Two said they'd just skip it.
So the second pass simplified that flow, added a bit of personal stats to the dashboard, labeled the capture types more clearly, and split the timeline so "recent" and "still open" weren't tangled together.
‣ Iteration 3: the one that changed everything:
Three in-person sessions, watching people think out loud, surfaced the real issue:
asking someone to categorize their own thought while they're mid-thought breaks their flow.
One person kept pausing, not to think about the material, but to decide which folder their idea belonged in.
That's the moment the name changed from "Check Point" to Thread, and the design caught up with it. The Anthropic API took over the categorizing completely. Now it's just a chat: type or speak, and it sorts itself into Note, Question, Key idea, or Next step. The to-do list stepped back from the spotlight.
And the four-step ending shrank into one, single auto filled summary you just glance at and confirm.
Restyling the home screen to emphasize the recent session while keeping the open sessions on surface as a reminder
Better sorting system for the session timeline to keep tracking of the topics and completed sessions
Design was only half the project, the rest had to actually run.
Thread is a full MERN app: MongoDB, Express, React, Node, all built solo. Wiring the Anthropic API into the capture flow took a few rounds of trial and error to get the categorization fast enough that it didn't interrupt the writing, nobody wants to pause mid-thought waiting for an AI to label it. Figma's Dev Mode helped keep the build honest to the design instead of drifting from it.
Code's on GitHub if you want to look under the hood:
Reflections
A few things became clear once real people actually used Thread.
The resumption card worked exactly as hoped, a glance at the last step, the next move, the open question, and use will just continue.
Handing categorization to AI was the bigger win, earlier versions asked people to label their own thoughts mid-session, and it kept breaking their focus. The moment that decision disappeared, writing felt like writing again.
The end-of-session summary never fully stopped feeling like a chore, even shrunk to one step — it's asking people to reflect right when they're most done thinking for the day. Worth being honest too: everyone who tested this came from my own circle, and every test was a single session. Whether Thread holds up over weeks of real, fragmented studying is still an open question.
Doing this entirely solo was its own lesson. There was no one to bounce a half formed idea off, no one to catch a blind spot before it became a wrong turn, every research question, design decision, and bug was mine to sit with until it made sense. It was slower than working with a team would've been, and harder some days than I expected. But it also meant I understood every part of Thread completely, not just the parts I happened to work on. That's a kind of ownership you don't get any other way.