The Empty JSON Lesson: When the First Stage of a Cricket Content Pipeline Returns Nothing

The most expensive failure on a sports desk is not the one that sets off an alarm. It is the one that quietly hands over an output which looks complete from the outside — the fields are there, the brackets are closed, the JSON is valid — and is entirely empty inside. The moment a system says 'N/A' instead of saying 'nothing', the desk begins to believe the work has been done. This report is an investigation into exactly one such incident. The case concerns a Stage-1 output. Stage-1 means the first layer that reads a raw text and builds its skeleton: what the headline is, what the source is, what kind of article it is, what the one-sentence summary is, what the author's stance is, what the article's purpose is, which facts it contains, which entities appear in it, how time-sensitive it is, and how good the source is. These ten or eleven fields are the foundation of everything downstream — summarisation, tagging, recommendation, editorial decisions. In this case the skeleton came back, but empty. Title: N/A. Source: N/A. Article type: Unclassified. One-sentence summary: blank. Author stance: N/A. Article purpose: N/A. The list of information points: empty. The entity field contained, instead of actual names, an instruction — 'identify from the information points above'. Time sensitivity was never assessed. Source quality carried the note that it should be judged from the source fields. In other words, not one field held anything that could be used downstream. Exactly one field in the entire structure was populated: Domain Label, with the value cricket_world. From that single fact, all that follows is that the article's subject belongs to the world of cricket. What does not follow is whether it is a match report, a player transfer story, commentary on ICC rules or finance, a matter of cricket betting or commercialisation, or a statistics-driven analysis of a domestic tournament. Those five kinds are read in completely different ways, and the path to a 'deep analysis' is different for each of them. This is where the real problem begins. An empty skeleton is not a neutral state; it is an input that forces every downstream model to fill something in from its own imagination. When a language model is asked to write an analysis based on these points, and the points do not exist, it has only two paths: refuse cleanly, or fabricate a structure that resembles analysis but has no actual relationship to the article. The second path is far more common, because it is cheaper and looks complete immediately. So it is worth asking why this happened. The empty skeleton has diagnostic value of its own. There are three plausible causes, and they can be ranked by probability. The first and most likely cause is that the upstream input was empty or the crawl failed. This is the most frequent and the least visible. Cricket websites today run on scorecard and live-blog templates whose main content is rendered by JavaScript. Conventional extractors fetch a page's HTML and pull text through selected CSS selectors. If the scorecard data is not in the server-side HTML but is injected later in the browser, the extractor receives a page that has the shell but is missing all the substance. The result: it returns an empty string. No error, no exception, just text of zero length. The second cause is classifier short-circuiting. The structure says the article type is 'Unclassified'. That is not a classification result; it is the name of a classification failure. If the pipeline is built so that summary extraction and stance detection both hang inside a type-dependent branch, then the moment the type comes back 'Unclassified', both branches are skipped. And if there is no general fallback after that skip, the fields simply stay at their default values. The design error here is not that branches exist; it is that when no branch matches, the process stops instead of proceeding through a general path. The third cause is the most revealing, and it is an instruction written into a field. The sentence sitting where entity names belonged — 'identify from the information points above' — is not a model's output; it is a template's placeholder. The implication is clear: that field was never actually filled. When the upstream information points were empty, the step responsible for populating the field either did not run, or ran and returned the template's original sentence. This is not missing data; it is a process bug. In missing data, a field stays empty. In a process bug, the field retains the instruction that was given to someone. Distinguishing between these three matters, because the remedies differ. If the problem lies in the first cause — the crawler received empty text — then improving the model's prompt will achieve nothing. You are sharpening the tool of a worker who never received the raw material. The first thing to check is whether extracting the same article separately yields a text length of zero. If it does, the fix belongs at the crawling layer: render with a headless browser, use a dedicated API for scorecards, or replace template-specific selectors with content-based extraction. If the text is arriving correctly, check the second cause: whether the post-classification branches are actually running, and whether a fallback exists for the 'Unclassified' state. The easiest fix here is to split the classifier into three states — confident type, probable type, unknown — and to extract a general summary even in the unknown state. Being unknown is an absence of information, not a reason to stop work. And if both are fine, the third cause remains: a template string being returned as a result. The remedy is direct — decide for every field what its value is built from, and treat as invalid any value that resembles an instruction. A simple check suffices: if a field's value begins with imperative verbs such as 'identify', 'judge', or 'extract', treat it as empty rather than filled. Now the question is what difference this makes to a sports newsroom. The difference is that cricket news is produced under the tightest time pressure. A match ends and within a few hours the score, the turning point, the reason for the result, the reactions — all of it must be ready. If the pipeline's first stage comes back empty and nobody catches it, the damage is twofold. First, the story that should have appeared is delayed or never appears. Second, and more seriously, the story does appear but in the wrong shape — because the model below fills the empty input from its own guesses. Failing to assess time sensitivity is a significant lapse in itself. In cricket, not every article ages at the same rate. A report filed during a match is measured in hours; commentary on a player's career in weeks or months; and debate about rules or administration over even longer spans. If the system cannot say which category an article belongs to, the publication decision is also made in the dark. Publishing an old story as fresh, and dismissing a fresh story as old, both grow from the same root. Failing to assess source quality is equally serious. The structure contained no information about the source at all, so there was no basis for judging quality. But in the real world this is the most important field. Where cricket news comes from — an official board release, an international body's document, a newspaper report, a social media post, or anonymous commentary — carries very different levels of trust. A pipeline that does not even know what the source is cannot apply a trust filter downstream. One point needs to be clear here. In the world of cricket, 'transfer', 'rules', 'finance', 'betting', 'statistics' and 'match' are distinct subjects requiring distinct kinds of scrutiny. A transfer story requires checking contract status and who made the claim. A rules story requires checking when a change takes effect and which body approved it. A statistics story requires checking which period a number covers and how it was computed. If the first stage cannot even determine which kind an article is, every downstream conclusion will be forced into one template — and that template will be wrong. There is a systemic lesson hidden in all of this, and it is that a system's greatest weakness is not its wrong answers but its empty ones. A wrong answer can be caught, because it can be compared against something. An empty answer cannot be caught, because it breaks no rule — it simply exists. And when a pipeline has many stages, an empty answer gets filled in a little at each stage, until finally it becomes an article in which every sentence is grammatically correct and factually hollow. This is why every stage of the pipeline should be measured for how much it returned. The most direct measure is logging length: the length of crawled text, the number of extracted information points, the proportion of fields filled. If these three figures were recorded alongside every article, this kind of failure would never pass silently. The second measure is contract checking. The pipeline's output should carry a condition that certain minimum fields cannot be empty, and that their emptiness is a clean failure rather than a warning-free acceptance. The third measure, and perhaps the most important, is not to treat N/A and an empty list as the same thing. They mean different things. N/A means the system looked, understood, and determined that the information is absent or inapplicable. An empty list means the system did not look, or looked and found nothing, and did not say which case applies. When code fills both from the same default, the distinction between 'there is no information' and 'no information was sought' disappears — and that distinction is precisely what editorial decisions need. Alongside this, a human safeguard is needed. Any automated summary should carry the condition that if its associated information points number fewer than three, it must pass through human eyes. This condition does not slow work down; it prevents the kind of error that is far more expensive to fix later. And it should also be decided that when Stage-1 returns empty for an article, publication of that article halts — it does not proceed on the strength of an 'N/A'. The question of responsibility is tied to this. If a factual error in a story came from an automated pipeline, accountability should rest with the person who approved that pipeline and the person who accepted its output for publication. 'The machine did it' is not an explanation; it is part of the problem. In a newsroom, every published sentence should have a name behind it, regardless of which tool built the sentence. What to do next follows in order. Step one: extract that same article separately and measure text length. If it is zero, fix the crawling layer, not the model's prompt. Step two: if the text arrives correctly, check the post-classification branches and add a general fallback for 'Unclassified'. Step three: define for every field where its value comes from, and declare instruction-like values invalid. Step four: log all three figures — text length, number of information points, proportion of fields filled — with every article. Step five: establish a rule halting publication on an empty Stage-1. The essence of all this is one sentence: a sports pipeline's worth is measured not by its best output but by its emptiest. Cricket news is a place where the margin for error is smallest, because numbers, names and times are all concrete and all instantly checkable by the reader. On such a field, a system that treats 'N/A' as an answer and moves on steals not the story but the trust. That empty JSON should therefore not be taken lightly. It is a story in itself — the story of how our machines, when they know nothing, hand over an empty skeleton instead of saying 'I don't know', and how we accept it as complete. That skeleton needs fixing. Even more, the habit that accepted it needs fixing.