The 4 levels of reducing hallucinations in your AI-assisted work

I build a lot of AI content workflows. Data analysis, newsletters, blog posts, reports, and news aggregations. Basically, anything where you take some source material, add some AI wizardry, and out pops something readable, usable, and ready for a final review before distribution.

It may not come as a surprise when I tell you that AI isn't the most, shall we say, reliable tool out there.

Achieving a 100% accuracy rate is infeasible without a human in the loop, but by using the right techniques, we can get pretty close.

You don't need to be an AI engineer to get something out of this advice. What follows are all techniques you can apply to normal everyday AI use to improve accuracy and reduce hallucinations.

Level 1: Grounding

Grounding is a technique where you provide the AI model with the specific information it needs to write its response rather than having it guess.

If you had asked AI to write you a blog post a couple of years ago, it would have relied on its training data alone.

Models are trained by feeding them enormous amounts of text. They learn how to speak from millions and millions of examples, but they also pick up on some facts and information too. However, relying on this training data alone results in really high hallucination rates.

The better approach, and what you'll see most models doing nowadays, is searching the internet to find some relevant sources before writing the response. Once they have read the reference material and it has been added to their context window, their accuracy in recalling it skyrockets.

This is a process known as grounding. You provide a model with the specific information you need it to refer to, and it is able to produce a far more accurate result with a far lower risk of hallucinations.

We can use this to our advantage by directing the model to refer to a specific web source—one that you actually trust and have vetted rather than whatever Wikipedia-like nonsense the model might otherwise choose itself.

If your task involves proprietary information (maybe a custom dataset, internal company documents, or other super-specific information that isn't publicly available on the internet), upload it directly.

If you've ever heard the term RAG being thrown around, this is the underlying principle that it relies on.

The job of a RAG system is to quickly fetch relevant snippets of information from documents and add them into prompts behind the scenes so that the model has accurate information to refer to when writing its response.

You can use tools like NotebookLM where the grounding is restricted specifically to the files and links you supply. It will also provide you with citations and references to the original source so you can quickly fact-check anything that doesn't quite look right.

Level 2: Task Decomposition and Specificity

Going one step further, we should consider how simple or complex our prompts are. Long, complex, multi-step prompts are only asking for trouble. If you need accurate results, have the model perform smaller steps at a time. Don't ask for an entire article in one go; ask for one section at a time and only supply it with the source material relevant to that section.

I used the same idea recently to build a workflow for generating data reports. We broke the report down into sections and gave the model only the data relevant to one section of the data at a time.

This brings us nicely on to level 3...

Level 3: Context Window Management

The context window is like the working memory of an AI model. If you keep using the same chat, the model has persistent memory of everything that has happened so far, but start a new conversation, and you have a blank slate—a separate context window.

The more data you add to the context window through your prompts, the lower the model's accuracy in recalling any one specific piece of information is. What this means is that, for tasks requiring really high-accuracy outputs, break the task down into individual components and use a separate chat for each one. Each should contain only the necessary information to complete that portion of the task and nothing else.

This is less important for short conversations with a few back-and-forth messages, and more important for hour-long conversations. In some tools (like Claude Code or similar agent platforms), once a conversation gets long enough, older history starts being compressed and summarised automatically to save space, which is another reason to keep individual chats focused.

Relatedly, this is less important if you have multiple messages related to the same task and more important when you want to change to a new task or idea. In general, when the context and current conversation are no longer relevant, open a new chat and start fresh.

Level 4: Critic-Actor Framework

So you sent your prompt, and you have your output. Now it's time to review. There's no reason we can't use AI to help with this too.

We can use an approach known as a critic-actor framework, where one instance of a model produces the work, and another criticises and reviews it.

Open a new conversation and supply the ground-truth source material as well as the AI-generated output you want to check. It's important not to continue in the same chat, as LLMs have been shown to favour their own output even when it's wrong. Ask the model to review all of the claims, facts, and figures and ensure they align with the source. As before, accuracy will improve here if you only supply the relevant portion of the source material rather than the entire thing (more so if the source is a particularly long PDF or large dataset). Using a restrictive grounding tool or RAG system like NotebookLM can be beneficial here too.

Often, the sorts of mistakes that may have been introduced aren't explicit errors, but claims that have been overstated, exaggerated, or twisted slightly in some way. Make sure to mention this to the model when you ask it to check the work so that it looks for the subtle differences as well as the completely outlandish false claims.

To push this one step further still, we can incorporate models from completely different families to reduce their shared 'blind spots' or tendency to make the same mistakes. It's worth noting this reduces but doesn't eliminate the risk — research shows models from different providers can still make correlated errors when their training data overlaps.

Designing your workflow

Ultimately, no matter how many measures you put in place, the only way to completely guarantee accuracy is to have a human review your work. The notion of human-in-the-loop is designed to combat this exact problem. We ensure that a human remains involved in critical steps in an AI-assisted workflow to ensure quality and accuracy and to incorporate the influence of style and taste that an AI model cannot bring.

For many writing and content workflows, it's only really necessary to have a human involved at the start and the end:

  • Qualifying and preparing source material
  • QA of the final output and altering sentence structure to read more naturally

Everything else can be outsourced as part of the AI workflow.

This is not going to give you a piece of brilliant literature, but often, that's not the goal. Aggregating and synthesising information, making it suitable for the audience to understand, and presenting it in an appropriate way.

The Simplicity-Accuracy Trade-off

With the confidence that, if there are any errors in the output, you will catch them yourself at the end, you can start making more informed choices about the suite of tools you use. We may still want to improve the accuracy of the output as this reduces the time taken to check and alter the final output, but if we could make the workflow dramatically simpler in exchange for a slight potential accuracy reduction, wouldn't that be worth it?

Pick and choose from the above advice to maximise accuracy and QA gains while keeping things as simple and straightforward for yourself as possible.

One writing workflow may be:

  • Use Gemini to research some sources and review them manually for quality and relevance
  • Upload sources to NotebookLM and use a prompt template to craft your output
  • Check manually using the provided citations
  • Start a new notebook with the same sources and the previously generated output. Prompt it to review the claims for how well they align with the original sources, specifically looking for exaggeration and slight inaccuracies in the way claims are being reported
  • Review the final output. It will likely be mostly correct, but you should still check.

That's 3 separate model instances, 2 different tools, and 2 human review points.

On the other hand, a different workflow might be:

  • An automation exports the latest data source from your database
  • An agent skill, with instructions on how to query the dataset using some code, is used by Claude to write a data analysis report in a specific format
  • Have Claude spin up a subagent to independently review the output for quality against a style guide, then another subagent to review for data accuracy against the same source data
  • Review the final output yourself before distributing

The subagent review will catch the majority of errors, but perhaps not with quite the same rigor as the NotebookLM workflow would. However, this second workflow would be far quicker to perform and could even be set up as a scheduled task to be completed before you even arrive at your desk in the morning.

Again, which one you choose will depend on the tools you are comfortable using, and how much time/how important the human QA step is.

While there are many steps we can implement to reduce hallucination rates, once you accept that keeping a human-in-the-loop is a necessary requirement for quality outputs, you can start making smarter tool choices.

References and Further Reading