When Do LLMs Actually Help? Evaluating LLMs as Data Quality Annotators

In the vast, humming infrastructure of modern commerce, data is the currency that keeps the lights on. Every time a customer searches for a product, receives a recommendation, or sees a price update, a massive database is being queried. But these databases are messy. They are filled with duplicate entries, misspelled brand names, and records that look similar but refer to different things. For decades, companies have relied on rigid, rule-based systems to clean this mess. These systems work like a strict librarian who checks if two book titles are spelled exactly the same; if they are, the books are the same. If they are not, they are different. This approach is fast and reliable, but it breaks down when the data gets complicated, such as when a product is listed under a nickname or a subsidiary brand. Recently, a new type of computer program, known as a large language model, has entered the scene. These models are trained on enormous amounts of text and can understand context and meaning in a way that simple rules cannot. They promise to act as intelligent editors, spotting errors that a rigid checklist would miss. But as organizations consider swapping their old tools for these new, flexible ones, a critical question remains: are these intelligent editors actually consistent, and do they truly offer an advantage over the old methods, or are they just expensive guesswork?

A researcher in Kathmandu set out to answer this by putting a specific large language model through its paces on two common data quality tasks. The first task was entity matching, which involves deciding whether two product listings describe the exact same item. The researcher tested the model against a dataset of over two thousand pairs of product records, comparing its performance to a simple, rule-based system that looked for overlapping words. The results were surprising. The simple rule-based system, which relied on counting shared words, performed almost perfectly, correctly identifying matches in ninety-five percent of cases. The large language model, using a straightforward prompt without any special instructions, performed just as well, achieving nearly the same score. In this specific scenario, where product names were largely literal and shared many words, the advanced intelligence of the model offered no real benefit over the basic word-counting method. The model did not get smarter; it simply matched the performance of the older, cheaper tool.

The story changed when the researcher tested the model on a different problem: detecting brand mislabeling. Here, the task was to determine if a product was assigned to the correct manufacturer. The researcher created a test set of five hundred product listings, some of which had been deliberately swapped with the wrong brand names. The simple rule-based system, which checked if the manufacturer's name appeared literally in the product title, failed badly. It flagged almost every item as an error because it could not understand that a product might be made by a parent company or sold under a subsidiary name. The large language model, however, drew on its internal knowledge of how brands relate to one another. It recognized that a product labeled with a stock ticker abbreviation was actually made by the full company name, and it correctly identified these relationships. In this task, the model significantly outperformed the rule-based system, catching errors that the simple checklist missed entirely. This demonstrated that the value of the model depends entirely on the job: it shines when the task requires understanding context and background knowledge, but it offers little advantage when the answer can be found by simply looking at the text.

Beyond accuracy, the study also investigated a hidden danger of using these models: consistency. If a human editor reads the same document twice, they should give the same answer. If a computer program gives a different answer each time it is asked the same question, it becomes unreliable for automated decision-making. The researcher ran the model through the same two hundred matching tasks five times in a row, allowing it a small amount of randomness in its thinking process. The results showed an almost perfect level of agreement. The model gave the exact same answer for ninety-nine percent of the items across all five runs. This high level of stability suggests that, for these specific types of binary decisions, the model is not a chaotic oracle but a reliable worker. However, the study also found that trying to make the model "smarter" by adding more examples to its instructions could backfire. When the researcher tried to improve the model's performance on the matching task by giving it specific examples of how to handle product codes, the model actually performed worse on the full dataset than it did with the simple instructions. The model had overcorrected, becoming too dependent on the codes and missing valid matches that didn't have them. This served as a warning that testing a new instruction on a tiny sample can be misleading; what works on a handful of examples does not always work on the whole.

The final takeaway is a nuanced guide for anyone looking to use these tools. Large language models are not a magic wand that automatically fixes all data problems. They are powerful tools that excel when the task requires understanding the world behind the words, such as knowing that two different names belong to the same company. But when the data is straightforward and the answers are hidden in plain sight, a simple, traditional method is often just as good and far less costly. The study suggests that organizations should not assume these models are superior in every situation. Instead, they should test them on their specific problems to see if the model's ability to understand context is actually needed. If the data is clean and the rules are clear, the old methods may still be the best choice. If the data is messy and the relationships are complex, the model may be the key to unlocking the truth. The path forward is not to replace all old systems with new ones, but to choose the right tool for the specific job at hand.