I Built an AI That Doesn't Give Advice. Here's What I Learned
I spent years publishing content.
Blogs.
Books.
Ideas.
Almost nobody cared.
A few months ago I stopped asking:
"How do I get more traffic?"
and started asking:
"Why do people avoid taking action even when they know what to do?"
That question turned into a side project called TruthLoop.
The idea is simple:
Instead of giving advice, the AI keeps asking follow-up questions to uncover the behavioral pattern behind a problem.
Not the symptom.
The pattern.
One thing surprised me while building it:
Most users don't lack information.
They already know what they should do.
They're avoiding something.
A difficult decision.
A conversation.
A risk.
A fear.
A contradiction.
The challenge wasn't building the AI.
The challenge was getting the AI to stop repeating itself and actually go deeper with each loop.
Still early.
Still tiny.
Still figuring out distribution.
But building a product has taught me more about human behavior than years of publishing content.
For founders building in public:
What's the biggest thing your product taught you that you weren't expecting?
This hit something real for me.
I'm building SoulMirror™ AI — it reads emotional state through smartphone camera signals in 60 seconds. No wearables. The tech side was never the hardest part.
The hardest part was the same thing you found: people don't lack information about their mental or emotional state. They're avoiding the mirror entirely.
What my early pilots taught me that I didn't expect: people are more afraid of confirmation than confusion. Confusion feels safe. Knowing feels permanent.
So the real design question stopped being "how accurate is the signal" and became "how do we make the truth feel safe to receive?"
Still figuring that out. But that question changed everything about how I'm building.
Following TruthLoop closely — feels like we're circling the same core problem from different angles.
This hits hard. Built Lumetrix Play for the exact same reason — students know they should practice coding instead of watching tutorials, but they keep watching anyway. The avoidance pattern is real. Curious what behavioral loop you see most often in TruthLoop users?
Interesting approach. Removing advice and just reflecting facts could reduce AI hallucinations. What was the biggest challenge in training it to avoid giving opinions?
The biggest thing building my product taught me was that the problem users describe isn't always the problem they actually have.
Shopify merchants said they wanted "better analytics" — what they actually wanted was someone to tell them what to DO next. The data was never the issue. The paralysis from not knowing how to act on it was. That completely changed what I built.
the getting the AI to stop repeating itself and actually go deeper with each loop is the hard problem that nobody talks about in AI product posts. most conversational AI tools feel like they're asking follow-up questions but are actually just rephrasing the same question in different words. the difference between a question that deepens understanding and one that just fills space is surprisingly difficult to engineer and the user notices immediately even if they can't articulate why. curious what the actual mechanism looks like for detecting whether you've gone deeper or just sideways
New explanations can be sideways.
Recurring contradictions are usually deeper.
The pattern matters more than the wording.
"Most users don't lack information. They're avoiding something."
That line is the most underrated insight in product building.
I ran into something similar building a research tool. Users would sit on the output for days without acting. Not because the answer was wrong, but because it surfaced a decision they didn't want to make.
What surprised me most: the users who engaged hardest were the ones who came back to challenge the AI, not the ones who accepted the first output. The second-round session was where actual clarity happened.
Your point about stopping the AI from repeating itself is the real hard problem. The loop has to feel like pressure, not a broken record. That is all conversation state and takes a lot of tuning.
Agreed.
Acceptance ends the loop.
Resistance often reveals the hidden pattern.
The behavioral gap you're describing — between knowing what to do and actually doing it — is probably the biggest underexplored problem in software.
Most tools optimize for giving better answers. But the bottleneck usually isn't information quality, it's activation energy. People don't need more insight, they need fewer steps between "I already know this" and doing the thing.
Building something that surfaces context instead of advice is counterintuitive but probably closer to how behavior actually changes. Curious what you found in terms of which "non-advice" prompts led to the most action from users.
That's a useful way to frame it.
The more conversations we analyzed, the more it seemed that insight wasn't the bottleneck.
The bottleneck was often the emotional cost attached to the next action.
The insight about users not lacking information but avoiding action really resonates. Building my own tool taught me the same thing — people know what they need, but friction (even tiny friction like uploading a file to a server) stops them. That's why I built everything client-side. The behavioral gap between knowing and doing is underestimated by most founders.
Agreed.
Friction matters more than most founders expect.
What's interesting is that even after friction is removed, some actions are still avoided.
That's where the behavioral pattern usually becomes visible.
Interesting observation. I've noticed something similar — people often know what they should do, but still don't act on it.
Curious: when users reach a deeper insight through the questioning process, do you see them actually taking action afterward, or mainly gaining self-awareness?
That seems like the hard part to measure.
Great question.
We can observe deeper self-awareness inside the conversation.
Measuring real-world action is much harder.
My current assumption is that awareness doesn't guarantee action, but action rarely happens without awareness first.
something my product taught me was how harder it is to manage AI, honestly AI sometimes doesn't listen it won't use specific files that will help it so you need to force it which is a hastle.
I can relate to that.
A surprising amount of AI product development ends up being about guiding the model toward the context you actually want it to use.
The model is powerful.
The challenge is getting it to focus on the right thing.
The "stop repeating itself and actually go deeper each loop" part is the bit I'd obsess over — it's the whole game. We're a team running AI models against each other in games like Mafia, and we hit the exact same wall: left alone, a model settles into a groove and paraphrases its last turn. Two things broke the loop for us — giving the model an explicit, changing state to react to each turn (so "this turn" is genuinely different from "last turn"), and forcing it to name what's new since the previous step before it's allowed to answer. Without that second step it just restates itself in fresh words. Your behavioral-pattern framing is sharp — do you persist a running summary of what the user has already dodged, so the next question can't circle back to covered ground?
Well said.
New wording isn't new insight.
The loop only deepens when it follows the contradiction, not the topic.
We hit a similar wall early on.
The breakthrough wasn't adding more explanation.
It was changing how the system detects and reacts to emerging behavioral patterns in real time.
Once the pattern changes, the response changes.
This maps to something I noticed while building DictaFlow. The gap between "I should capture this" and actually doing it isn't just emotional, some of it is plain typing friction. Hold a hotkey, speak, release, and the thought is on the page before the hesitation loop kicks in. Removing the physical bottleneck doesn't fix the behavior pattern, but it does take away the "this will take too long to type" excuse that keeps it going.
Agreed.
Lowering friction helps.
But when the task is still avoided after friction disappears, there's usually a deeper behavioral pattern underneath.
Mine taught me the same thing from another angle: job-seekers know they should tailor each application and follow up — they just avoid it, so they spray 100 generic ones instead.
The product's real job isn't giving information, it's lowering the cost of doing the scary, specific thing.
That's a useful way to frame it.
Sometimes the bottleneck isn't information.
It's the emotional cost attached to the next action.
The "stop repeating, go deeper each loop" problem is usually less about the prompt and more about state — the model has no memory of which dimensions it already probed, so it circles back. One thing that tends to break the loop is feeding a short running list of "angles already explored" back in on each turn, so the next question is forced onto ground you haven't covered yet.
On your actual question: building a tiny iOS memo app solo taught me people don't skip a feature because it's hard — they skip it because the next step isn't obvious. Same avoidance you're naming, just at the UI layer. Does going deeper actually change what users do, or only what they're willing to admit?
Not always behavior immediately.
But it often changes what behavior means to the user.
Once the pattern becomes visible, avoidance gets harder to justify.
The "they already know what to do, they're avoiding something" insight is the most underrated thing in this space. I build automation for small businesses and hit the same shape: the bottleneck is almost never that they don't know a task should be automated — it's that they don't trust handing it over. So the product became less about clever
automation and more about earning trust: show its work, fail loudly, let them keep a hand on the wheel. On your repetition problem — what helped me get an AI to go deeper instead of looping was forcing it to summarize the pattern-so-far before each new question, so it can't re-ask what it already knows. Have you tried that between loops?
Not exactly.
The loops aren't pre-written.
Each question is generated in real time from the user's input and the behavioral patterns uncovered so far.
The system isn't trying to reach a predefined answer.
It's trying to follow the pattern until the explanation no longer holds.
That's a cleaner design than scripting loops — makes sense. The part I'd find hardest is the stopping condition: how does it know the explanation "no longer holds" vs. just hasn't dug deep enough yet? It's the same problem I keep hitting on my side — knowing when an agent has actually done the job vs. just produced more output. With behavior it's even trickier, because people hand you a tidy explanation that sounds final but is really just the next layer of avoidance. Curious how you detect "we've hit the real pattern" — is it the model's judgment, or are you watching signals in how they answer (hesitation, contradictions, shorter replies)?
The pattern usually arrives before the answer.
Different explanations.
Same contradiction.
That's often the clue we're getting closer.
This is a big problem, the repetition that can lead to exhaustion... sometimes it really feels like we're in a continuous loop, and sometimes it almost forces us to reset... the human mind plays tricks on us, what we don't need is an assistant, AI, playing repeated and looping tricks on us... The TRUTH is often uncomfortable and we don't like it, so I'm quite curious to see what results you'll get with this tool and what paths it can lead us down. Good luck with what's to come, always with TRUTH and without LOOPS...
Well said.
The uncomfortable part is rarely the insight itself.
It's the contradiction the insight exposes.
That's where hidden patterns tend to reveal themselves.
The technical challenge you mentioned about preventing the AI from repeating itself and driving deeper into the loop is massive. When I was building my project, I experienced something similar, we expect users to want the fastest path to an answer, but my biggest surprise was that building for friction is sometimes better than building for speed. If a tool makes things too easy, the user doesn't value the output or engage with the actual problem. How are you structuring your system prompts or state management to ensure the AI recognizes it’s hitting an emotional roadblock rather than just a technical one?
Interesting observation.
Technical blockers disappear when the environment changes.
Emotional blockers tend to follow the user into the new environment.
That's usually the signal that the loop is deeper than the task itself.
wow that's cool
Most of the language learners, including me, learn languages primarily focusing on grammar and vocabulary and completely forget about the core part which is speaking -after some learning. And most of the language learning apps doesn't provide the opportunity to speak. That's how LangSpeak was born.
It let's the learners speak in their preferred language. Because application of what we know returns more than just focusing on theory only.
As you said, "They're avoiding something" they're sitting in their comfort zones instead of speaking.
Well said.
Grammar wasn't the bottleneck.
Speaking was the exposure point.
That's often where hidden resistance becomes visible.
Answering your question directly: building an AI daily planner taught me that the friction isn't in making the plan — it's in the gap right after the plan is made. Users would create a detailed, organized schedule and then not return until the next day to plan again. The planning itself had become the comfort behavior, a substitute for action rather than a trigger for it. It completely reshaped what I focused on: instead of helping people plan better, the more useful thing was building nudges that help them actually start on what they'd already planned. Your framing of people "avoiding something" rather than "lacking information" is exactly right — it's the same pattern showing up in a different context.
What stands out is that the obstacle moved.
It wasn't in the planning phase.
It was hiding in the transition from clarity to action.
That's where hesitation loops tend to become visible.
the insight about users already knowing what to do hits hard
i noticed the same thing validating my own product — people don't have an information problem, they have a friction problem. they know their notion workspace is a mess. they just never fix it because starting feels overwhelming.
the product that removes the first step wins, not the one that gives more advice
what does a typical loop look like before a user hits the pattern you're looking for?
Same — half the people I talked to could describe the perfect move and still hadn't made it. Knowing was never the gap.
Interesting distinction.
What I've noticed is that users rarely begin with the real constraint.
They begin with the explanation.
The loop keeps following the hesitation until the explanation stops changing and the underlying protection pattern becomes visible.
the explanation stops changing" — that's a sharp way to put it
so the loop is essentially waiting for the user to run out of new reasons and hit the actual thing they're protecting
that's not a chatbot. that's closer to therapy infrastructure
Maybe.
I think it's closer to pattern recognition than therapy.
The loop isn't trying to explain the user.
It's trying to make the hidden pattern visible.
One thing I’d be careful about:
It’s not about understanding value or taking action.
The real constraint is what users must believe is true before they trust the system enough to engage at all.
That underlying assumption often decides whether the product feels obvious or confusing.
This is the part most people skip.
For anything that hands you answers, the first real question is "can I trust this?" — and if that's shaky, no feature fixes it.
How are you earning that trust early?
That's a useful distinction.
The question isn't only what people are avoiding.
It's what assumption makes the avoidance feel reasonable in the first place.
Behavior usually makes sense once the hidden belief becomes visible.
The "already know, still avoiding" pattern shows up in the AI tool space too.
A lot of founders and consultants know they should be using AI to process contracts and research docs. They have the knowledge. But a specific friction stalls them: what happens to their files once they upload them? Most tools train on everything by default.
The avoidance isn't about capability. It's about a concrete risk they can't see resolved.
I've seen that shift with goffer.ai, a private document vault that doesn't train on your files. Once that concern is off the table, adoption moves fast. The product is basically "absence of a problem" rather than a feature list.
Your framing about the behavioral pattern underneath a problem is useful here. The blocker is almost never what people first say it is.
Exactly.
People rarely resist the action itself.
They resist the consequence they expect from the action.
Once the perceived risk changes, behavior often changes much faster than expected.
One thing I'd be careful with:
The challenge may not be whether people lack information or even whether they're avoiding action.
The harder decision could be what users need to believe is happening before they trust the questioning process enough to continue.
That sounds subtle, but it can quietly shape who the product resonates with and how it's evaluated.
That's a good point.
A question can create insight.
But only if the user believes the next layer is worth uncovering.
Trust is part of the loop too.
Possibly.
The reason I'd still be careful is that trust can mean several different things while appearing validated by the same behavior.
That's one of those decisions I'd want confidence in before building too much around it.
I wouldn't try to unpack that properly in a thread.
If you're curious, drop your email and I'll put together the tighter version.
Agreed.
Questions create insight.
But only when people believe the process is helping them discover something, not forcing them toward a conclusion.
Trust isn't separate from the loop.
It's part of the loop itself.
Possibly.
The reason I'd still be careful is that some decisions can feel validated long before they're actually understood.
That's the part I'd want confidence in.
I wouldn't try to unpack that properly in a thread.
If you're curious, drop your email and I'll put together the tighter version.
Fair point.
Agreement isn't the signal.
Pattern change is.
People can accept an explanation without understanding it.
It's much harder to sustain a new behavior without understanding it.