Almost? originally started as a reflection app for logging near misses. The idea was simple: capture moments where something almost went wrong, reflect on them, and hopefully learn something useful.
That version was thoughtful, but it had a problem.
It was mostly passive.
You could log an almost, tag how it felt, mark a few entries as meaningful, and revisit them later. That created a record of insights, but it did not reliably change behavior. The app helped describe near misses, but it did not yet guide what to do about them.
Over time it became clear that reflection alone was not enough. The app needed a loop.
Why a reflection app was not enough
The original version focused on individual entries.
You logged an almost, added context, maybe tagged your mood, and occasionally looked back at older entries. That structure worked well for capturing experiences, but it stopped at reflection.
The missing piece was what should happen next.
If someone logs a few almosts that point to the same underlying pattern, the interesting moment is not the entry itself. The interesting moment is recognizing the pattern and deciding how to adjust.
The app had the raw material, but it did not yet turn that material into action.
That question led to a much better product framing.
What should happen after someone logs a few almosts?
From reflection to behavior change
Answering that question changed the entire structure of the app.
Instead of treating almosts as the final artifact, the app now treats them as input to a small behavior loop:
- capture almosts quickly
- review recurring patterns
- turn patterns into adjustments
- keep those adjustments active, stabilize them, or archive them later
The unit of value stopped being the entry and became the adjustment.
Almosts are still captured and stored, but they now function as evidence. When several of them cluster into something recognizable, the app shifts focus from describing what happened to deciding what should change.
That shift turned Almost? from a reflection tool into a behavior change system.
How the new loop works
The first step is capture.
Almosts can now be logged quickly through a lightweight capture flow. You add the near miss, optionally review or edit the suggested tags, and deliberately decide whether to save or discard it. The goal is to make capturing moments frictionless without turning it into endless journaling.
The second step is pattern review.
When several almosts begin pointing to the same underlying issue, they appear together for review. Seeing them side by side changes the experience. Instead of isolated reflections, they become a pattern worth responding to.
From there the app suggests creating an adjustment: a simple behavioral correction based on what those almosts reveal.
Adjustments then have a lifecycle.
They can be suggested, become active, eventually stabilize once they feel natural, or be archived if they are no longer relevant. The app deliberately limits how many adjustments can be active at once so the system stays focused instead of turning into a list of good intentions.
Reflection stayed, but it stopped being the endpoint.
Product decisions that mattered
Two design decisions made the loop work better.
First, active adjustments are limited. Behavior change only works if attention is focused. If dozens of rules are active at the same time, none of them matter. Limiting active adjustments forces prioritization.
Second, review should only appear when it is useful.
Instead of constant reminders or daily streak mechanics, the app nudges review when enough almosts have accumulated to make it meaningful. That keeps the system from becoming another notification stream.
The rebuild was less about adding capability and more about clarifying what the app is actually for.
What rebuilding the app taught me
The biggest lesson was that storing reflection is not the same thing as closing a loop.
The old version of Almost? could store thoughts. The new version tries to turn those thoughts into behavioral corrections. Near misses became raw material for adjustments rather than isolated entries.
That change moved the center of gravity in the app. Recent almosts are still visible, but they are now evidence. The real focus sits higher in the interface: patterns, adjustments, and what to do next.
A reflective tool became a behavior loop.
And this version is the first one that actually feels aligned with the original purpose of the idea.
