I built an AI tool that tells founders the truth — even when the truth is uncomfortable.

Most discussions about LLM hallucinations focus on UX problems. Wrong facts in a paragraph. A made-up citation. A link that doesn't exist.

For founders, the failure mode is much more expensive.

When an AI confidently fabricates market demand, invents competitor weaknesses, or manufactures willingness-to-pay where none exists — and you build on top of that foundation — the cost isn't an incorrect sentence. It's six months of your life spent building toward a fake opportunity.

I've watched this happen. I've felt early versions of it myself. You emerge from a ChatGPT session with momentum and conviction, both of which feel like validation but are really just enthusiasm reflected back at you. Then you build. Then you talk to real users. Then reality arrives.

The gap between AI-generated confidence and market reality is where most early-stage startups quietly die.

Painstack is a problem-first startup ideation tool. You paste a problem — a Reddit complaint, a forum thread, your own description of something you've noticed — and the system analyses it and returns a structured blueprint.

But what happens under the hood is the important part.

When I designed the architecture, I wanted the system to behave like a validator, not a cheerleader. Every problem runs through a sequence of constrained agents, each answering a specific question:

Problem parser. Normalises the input into a testable statement: who, what pain, in what context. Forces specificity before anything else happens.

Signal extractor. Looks for real external evidence: frequency of complaints, existing workarounds, channels where the problem appears. Not "it sounds plausible" — actual signal.

Scoring engine. Applies a fixed rubric across frequency, intensity, and willingness to pay, producing a 0-100 problem score via a transparent formula. Not because the LLM said so.

Solution mapper. Proposes three structurally different directions: direct, adjacent, vertical. Not a feature list — actual strategic options with different assumptions.

Risk checker. Stress-tests the idea against known patterns: crowded markets, weak monetisation, low switching incentive, heavy network effect requirements. Named, not vague.

Roadmap composer. Turns the analysis into a 90-day validation plan: who to talk to, what to test, what a genuine positive signal looks like.

Each agent has its own prompt, guardrails, and expected output schema. The LLM doesn't get to riff. It has to fill in structured fields inside a pipeline we control. That's what turns a probabilistic language model into a repeatable validation engine.

LLMs guess the next token that looks most likely. That's useful for language generation. It's dangerous when you're deciding whether to spend a year of your life on an idea.

The way Painstack addresses this is by wrapping the model with structure it can't ignore:

A fixed problem schema — actor, context, pain, current workaround, triggers, consequences. The model maps free-form text into this schema before anything else happens.

A deterministic scoring formula — frequency, intensity, and willingness to pay each score on a fixed scale. The final number is calculated, not generated. You can verify the arithmetic yourself.

A pattern library — known tar-pit archetypes, monetisation traps, structural warning signs. The model checks against this catalog rather than inventing risk from scratch.

A validation-first output rule — every blueprint must include a concrete next step. No action plan, no valid blueprint.

The result: the LLM is not deciding what is true. It's arguing its case inside rails we control. When it claims high willingness to pay, it must point to specific behaviours — existing spend, paid workarounds, documented complaints. When it flags a risk, it has to name the pattern, not just the concern.

Think of it as a powerful intern with strict checklists. The intern is fast, well-read, and genuinely useful. But they're not the one making the final call, and they can't skip steps.

Most tools stop at the score. Painstack doesn't.

Once a problem scores above 70, the system shifts into execution mode. The CTO agent defines MVP scope, suggests a tech stack proportional to the problem's current validation stage, and generates platform-specific build prompts for tools like Lovable, Replit, and Cursor.

Validation without execution is expensive research.

The founders I designed this for aren't looking for another document to file away. They're trying to decide what to build — and then actually build it. The blueprint is the bridge between "this problem is real" and "here is the minimum thing you should build to test the hypothesis."

Twenty founders have gone through Painstack since launch. Seven are paying. That's a 35% free-to-paid conversion in month one, and roughly €175 MRR.

The number that matters more to me: average validation time under 5 minutes.

Not because speed is the goal. Because the founders who used it said the same thing in different ways: "I would have spent two weeks convincing myself this was a good idea. This told me in five minutes that I needed to talk to actual people first."

That's the product working.

I could have written an essay about the problem of idea-first thinking. I already did — it's on this blog.

But there's a gap between knowing that you should validate problems before building solutions, and having a system that makes it easy to do that consistently. The essay tells you the principle. Painstack operationalises it.

The tool is designed for the version of myself that gets excited about ideas at 11pm and needs something to slow that down before the excitement becomes a build sprint based on nothing real.

It won't guarantee your startup succeeds. But it makes it significantly harder to lie to yourself about the problem you're solving — and in a world where AI makes it easier than ever to manufacture false conviction, that friction is worth something.