DEV Community: nexomind

I Built a System That Detects Thought Loops in Human Writing

nexomind — Wed, 10 Jun 2026 02:34:38 +0000

Most people frame overthinking as a feelings problem. i started treating it like a systems problem.

What if overthinking isn't about thinking too much - but about the same computation running repeatedly without reaching a termination condition? What if the brain is just stuck in a recursive loop with no base case?

That reframe changed how i built NexoMind. And it changed what the product actually does.

The problem: recursive thoughts without exit conditions

Here's what overthinking looks like if you model it structurally:

function think(problem, emotionalState) {
  const newEmotion = reprocess(problem, emotionalState)
  // no exit condition
  // no new information generated
  // just re-invocation with mutated state
  return think(problem, newEmotion)
}

The thought content stays static. The emotional wrapper mutates each cycle. That mutation creates the illusion of progress. "i'm getting closer to figuring this out." You're not. You're just recursing with a different emotional parameter.

No stack overflow though. The brain happily runs this forever.

5 loop types i identified

After reading pattern data across users (we see pattern types and frequencies, never content - E2EE), these structures kept appearing:

1. Replay Loop - Re-executing a past event trying to find the branch where the outcome changes. It never does. The past is immutable state.

2. Preparation Spiral - Generating increasingly catastrophic scenarios under the label "planning." No action items produced. Just escalating threat models with no mitigations.

3. What-If Fork - Toggling between N bad outcomes. Classic busy-wait. CPU usage at 100%, throughput at zero.

4. Clarity Illusion - The belief that more cycles = eventual convergence. But there's no convergence condition. The function never returns.

5. Identity Loop - Meta-recursion. "What does it say about me that i'm thinking this?" Thought about thought. Infinite regress disguised as introspection.

How detection works (conceptually)

The interesting technical challenge: how do you detect when someone is looping vs. genuinely processing?

The signal isn't in any single entry. It's across entries over time.

What we look for:

Semantic similarity clustering - same theme appearing in entries that the user frames as "different problems"
Emotional variance without content variance - the feeling changes but the underlying concern doesn't
Trigger recurrence - same environmental trigger producing same response pattern
Resolution absence - no new information, decisions, or action items across multiple entries on the same topic

Single-entry analysis catches the obvious loops (replay, what-if fork). Cross-entry pattern detection catches the subtle ones (identity loop, preparation spiral that spans weeks).

What i learned about building this

Less AI output = better UX. Early version gave 300-word responses. Users read them, said "helpful," never came back. Cut to 4 lines. Return rate doubled. The AI's job is naming, not explaining.

The base case is external. You can't detect your own loops from inside them. That's the whole reason the tool exists. Something outside the system has to say "this is the same pattern you had last tuesday."

Precision > comfort. Users don't want to feel validated. They want to feel seen. "You're experiencing the replay loop and the underlying concern is about respect" lands harder than two paragraphs of empathetic filler.

Privacy is load-bearing. People won't write honestly if they think someone's reading it. The whole detection system becomes useless if the input is self-censored. E2EE isn't a feature checkbox. It's what makes the data honest enough to be useful.

The moment that validated the approach

3am on a tuesday. Second night stuck on the same thought loop about a collaborator interaction. Two nights of my brain telling me it was "almost" figured out.

Opened my notes app. Wrote one sentence: "i think i'm afraid they don't respect me and i'm using the comment as evidence."

Loop broke. Not because i solved the problem. Because i named what the thought was doing instead of engaging with what it was about.

That's the entire product thesis in one interaction. Help people name the function, not just the argument being passed to it.

Current state

NexoMind does:

Single-entry loop detection (names the pattern type)
Cross-entry pattern clustering (surfaces recurring themes over time)
Cognitive distortion labeling (standard CBT taxonomy)
One-line reframes (precision, not essays)

What i'm still figuring out:

When to surface a pattern vs. letting the user discover it naturally
How much historical context improves detection accuracy vs. adds noise
The right threshold for "this is a pattern" vs. "this happened twice" (currently calibrating)

If you're building in the AI-for-thinking space, i'd love to compare notes. The interesting problems aren't the LLM calls. They're the data modeling and UX constraints around when to reflect something back vs. when silence is better.

NexoMind if you want to try it.

I built an AI journal that doesn't try to fix you

nexomind — Tue, 19 May 2026 23:45:08 +0000

It was 2:47 AM when I gave up trying to sleep.

I'd been replaying a conversation from earlier that day — one that, by any reasonable measure, had already ended fine. The other person had moved on. I was the only one still in the room, doing the math.

I opened a journaling app. Stared at the blank page for a minute. Closed it. Opened a chatbot. Got an over-eager pep talk that made it worse. Opened my notes app. Wrote half a sentence. Deleted it.

Nothing on my phone fit the shape of what I actually needed.

That's when I started building NexoMind.

What I actually wanted (and couldn't find)

Most journaling apps assume you know what to write about. They hand you prompts like "what are you grateful for today?" That's not the problem at 2:47 AM. The problem is that your brain has fourteen unresolved threads from the day and it's trying to file them all at once. Asking it to be grateful is like asking a fire alarm to consider its tone.

Most chatbots want a conversation. They keep going. Each reply pulls you a little further from what you came in with. By message six you're solving a different problem.

Therapy apps want a structure that takes twenty minutes and a clear head. I had neither.

What I wanted was something that would just read what was looping in my head and tell me what was actually inside it. Not advice. Not a quote. Not a coping strategy. Just — what's there?

The shift that changed what I was building

I spent a few weeks reading about why thought loops happen. Most of what I found was advice. Try meditation. Try CBT. Try grounding techniques. All useful. None of them addressed the actual mechanic of the loop.

The thing I kept coming back to: a thought loops when the feeling underneath it hasn't been named.

Not "felt." Not "expressed." Named. In a single word.

You can write three pages about a difficult conversation and still not know whether what you're holding is hurt, or pressure, or fear of being misunderstood. The loop keeps running because it's protecting an emotion that hasn't been identified yet. Once you name the emotion, the loop has somewhere to land.

That sentence — the loop has somewhere to land — became the design brief.

What I actually built

NexoMind is small. You write what's on your mind. It reads it once and reflects it back as four short pieces:

The trigger — what set this off
The thought loop — what your mind keeps doing with it
The distortion — the angle the loop is running at
The clarity — a calmer reading of the same situation

That's the whole product. There's a longer-form version inside the app that tracks patterns over time, but that one screen — four labels, four sentences — is the heart of it.

It's a different shape of journaling than I'd seen before. It doesn't try to make you write more. It does the structuring step you'd otherwise skip. The bet is that naming the loop is what releases it — not arguing with it, not reframing it, not solving it.

A note on the architecture

The public analyzer is intentionally minimal:

React on the front, single edge function on the back, structured-output prompt that returns a four-field JSON object.
The public-tool input is processed once and discarded. No database write, no user identifier. The full journal app stores reflections, but the public tool deliberately doesn't — it's a single-shot reflection, not a session.
The four-field shape constrains the model. Open-ended chat completions kept giving me wandering, comforting answers. A typed schema forces the model to commit to naming the parts instead of consoling the user. That single design choice changed the feel of the whole product.

The hard part

The hard part wasn't the model. The hard part was the temptation to make it say more.

Every time I showed an early version to someone, I'd watch them read the result, sit with it for two seconds, and then look at me — wanting more. Wanting comfort. Wanting a five-step plan. And every time, I had to remind myself: the comfort comes from being seen accurately, not from being told what to do.

I cut features for months. I cut the suggested next steps. I cut the "would you like to talk about this more?" prompt. I cut the mood score. I cut the streak counter. I cut everything that asked the user to do something with the result.

The product got smaller every week and felt better every week.

Software is mostly the practice of not adding things. I keep relearning that.

You can try it without signing up

There's a public version of the analyzer — no account, no email, nothing stored. Paste a thought that's been looping and it'll show you the four parts. It runs once and forgets.

If the result doesn't land, that's useful too. It tells you the model didn't catch what's underneath, which usually means the thought has more layers than one read can reach. The full app handles that with longer reflections over time.

Where it's going

NexoMind is what I wished I'd had on every 2:47 AM that sent me looking. It's not therapy. It's not a chatbot. It's not a habit tracker. It's a quiet way to stop overthinking without being told to think differently.

If you've ever wanted a tool that just reads what's there, it lives here.

Thanks for reading. Happy to answer questions about the architecture or the design constraints in the comments.
`