That framing resonates a lot. In production, creativity is often just unbounded variance.
Once each step is intentionally boring and constrained, failures become predictable and debuggable — which is what engineering actually optimizes for. That tradeoff is almost always worth it.
I’m building Verdic Guard (verdic.dev) around the same idea: treat LLMs as creative generators, but enforce scope and correctness outside the model so systems stay calm under load.
That’s a very real example of the core problem: LLMs don’t reliably honor constraints, even when they’re explicit and simple. Instruction drift shows up fast in learning tasks — and quietly in production systems.
That’s why trusting them “agentically” is risky. The safer model is to assume outputs are unreliable and validate after generation.
I’m working on this exact gap with Verdic Guard (verdic.dev) — treating LLM output as untrusted input and enforcing scope and correctness outside the model. Less about smarter prompts, more about predictable behavior.
Your Spanish example is basically the small-scale version of the same failure mode.
A helpful way to learn this is to separate models, machines, and practice.
For computation models, the circuit model and measurement-based computation cover most real work. Aaronson’s Quantum Computing Since Democritus and Nielsen & Chuang explain why quantum differs from classical (interference, amplitudes, complexity limits).
For computers/architecture, think of qubits as noisy analog components and error correction as how digital reliability is built on top. Preskill’s NISQ notes are very clear here.
For programming, most work is circuit construction and simulation on classical hardware (Qiskit, Cirq). That’s normal and expected.
Beyond Shor, look at Grover, phase estimation, and variational algorithms—they show how quantum advantage might appear, even if it’s limited today.
The real risk with LLMs isn’t when they fail loudly — it’s when they fail quietly and confidently, especially for non-experts or downstream systems that assume structured output equals correctness.
When you don’t already understand the domain, AI feels infallible. That’s exactly when unvalidated outputs become dangerous inside automation, decision pipelines, and production workflows.
This is why governance can’t be an afterthought. AI systems need deterministic validation against intent and execution boundaries before outputs are trusted or acted on — not just better prompts or post-hoc monitoring.
That gap between “sounds right” and “is allowed to run” is where tools like Verdic Guard are meant to sit.
That’s fair — if you’re already skeptical and paying attention, the failures are obvious and often funny. The risk tends to show up more with non-experts or downstream systems that assume the output is trustworthy because it looks structured and confident.
Autocomplete failing loudly is annoying; autocomplete failing quietly inside automation is where things get interesting.
This matches our experience too. The biggest reduction in hallucinations usually comes from shrinking the action space, not improving the prompt. When inputs, tools, and outputs are explicitly constrained, the model stops “being creative” in places where creativity is actually risk.
It’s less about smarter models and more about making the system boring and deterministic at each step.
Fair enough. A healthy dose of skepticism has served us well for every overhyped wave so far. The difference this time seems to be that AI systems don’t just fail noisily — they fail convincingly, which changes how risk leaks into production.
Treating them with the same paranoia we applied to web scale infra and crypto is probably the right instinct. The chupacabra deserved it too.
This matches what I’ve seen as well. A lot of “debt relief” and “settlement” services are essentially rent-seeking intermediaries that leave consumers worse off or stuck in long programs with unclear outcomes.
Non-profit credit counseling (with transparent fee structures and regulatory oversight) tends to be the only consistently legitimate option. Anything that promises easy reductions or fast fixes should probably be treated with extreme skepticism.
Consumer finance is one of those areas where incentives are misaligned enough that doing nothing is often safer than trusting a glossy solution.
That’s a very sane stance. Treating LLM output as untrusted input is probably the correct default when correctness matters.
The worst failures I’ve seen happen when teams half-trust the model — enough to automate, but still needing heavy guardrails. Putting the checks outside the model keeps the system understandable and deterministic.
Ignoring AI unless it can be safely boxed isn’t anti-AI — it’s good engineering.
This is a very pragmatic take. The “90% accuracy is a liability” line resonates — in high-stakes systems, partial automation often costs more than it saves.
What I like here is the field-level confidence gating instead of a single document score. That maps much better to real failure modes, where one bad value (amount, date, vendor) can invalidate the whole record.
One question I’m curious about: how stable are the confidence thresholds over time? In similar systems I’ve seen, models tend to get confidently wrong under distribution shift, which makes static thresholds tricky.
Have you considered combining confidence with explicit intent or scope constraints (e.g., what the system is allowed to infer vs. must escalate), rather than confidence alone?
Overall, this feels much closer to how production systems should treat AI — not as an oracle, but as a component that earns trust incrementally.
This resonates. A lot of AI reading tools optimize for removal of effort (summaries, shortcuts), which often ends up weakening comprehension rather than strengthening it.
One thing I’m curious about: how do you decide when the AI should intervene versus stay silent? In deep reading, timing matters a lot — too much contextual help can break flow, too little can frustrate.
Have you observed differences across use cases (e.g. technical papers vs. philosophy vs. fiction)? It feels like the “right amount” of AI assistance probably isn’t static and might depend on reader intent and text difficulty.
Interesting direction overall — especially the idea of AI as a reading companion rather than a replacement.
Whether or not Hallucination “happens often” depends heavily on the task domain and how you define correctness. In a simple conversational question about general knowledge, an LLM might be right more often than not — but in complex domains like cloud config, compliance, law, or system design, even a single confidently wrong answer can be catastrophic.
The real risk isn’t frequency averaged across all use cases — it’s impact when it does occur. That’s why confidence alone isn’t a good proxy: models inherently generate fluent text whether they know the right answer or not.
A better way to think about it is: Does this output satisfy the contract you intended for your use case? If not, it’s unfit for production regardless of overall accuracy rates.
Interesting reflection — but I’d push back on treating surface similarities between human conversational quirks and LLM failure modes as evidence they’re really the same thing. The article lists things like “not stopping generating,” “small context window,” and “repeating mistakes,” and frames them as if current LLM patterns are just human behaviors seen through a new lens.
The key difference is mechanism. For humans, wandering off topic or repeating a point usually stems from attention, memory, or social dynamics. For LLMs, similar-looking behavior often arises from architectural and statistical limitations — e.g., limited context windows causing context drift that makes the model lose track of earlier facts over long conversations. That’s been documented as a core technical barrier in conversational AI systems.
Likewise, what the article calls “persistent hallucination” isn’t just “being confidently wrong like a human might be” — it’s a systemic property of how LLMs predict the next token based on learned patterns rather than grounding in external truth. Hallucinations are literally outputs that are factually incorrect or fabricated even if they read fluently. That’s why engineering teams talk about hallucination detection, grounding, or external verification layers for production use.
Framing them as the same as human flaws risks obscuring the real challenge: deploying LLMs in systems where correctness, consistency, and adherence to explicit intent matter. Those aren’t just philosophical problems; they’re system-design constraints that require mechanism-aware validation and monitoring, not just metaphors to human behavior.
This framing resonates a lot. The core issue you’re pointing at isn’t model accuracy, it’s epistemic accountability.
In most current deployments, an AI system’s output is treated as transient: generated, consumed, forgotten. When that output later becomes contested (“Why did the system say this?”), organizations fall back on proxies—training data, benchmarks, prompt templates—none of which actually describe what happened at decision time.
Re-running the system is especially misleading, as you note. You’re no longer observing the same system state, the same context, or even the same implicit distribution. You’re generating a new answer and pretending it’s evidence.
What seems missing in many governance frameworks is an intermediate layer that treats AI output as a decision artifact—something that must be validated, scoped, and logged before it is allowed to influence downstream actions. Without that, auditability is retroactive and largely fictional.
Once AI speaks directly to users, the question shifts from “Is the model good?” to “Can the institution prove what it allowed the model to say, and why?” That’s an organizational design problem as much as a technical one.
Once each step is intentionally boring and constrained, failures become predictable and debuggable — which is what engineering actually optimizes for. That tradeoff is almost always worth it.
I’m building Verdic Guard (verdic.dev) around the same idea: treat LLMs as creative generators, but enforce scope and correctness outside the model so systems stay calm under load.