conan123/hittheroaddude-guides

Hit the Road Dude guides: internal link graph and navigation audit (Dataset Card v9, 2026-11-13)

What changed in v9 (2026-11-13): one new file and two scripts. data/link-graph-2026-11-13.jsonl has 2,190 links from 40 pages of hittheroaddude.app, each with the part of the page it sits in (header, nav, main or footer), its anchor text, where it points and the HTTP status of that target. validate_links.py checks the file shape, re-fetches the 40 pages to see whether any link changed, re-checks the targets, prints graph statistics and scores three link-prediction baselines. link_graph_lib.py is the parser it shares with the build step. Everything from v1 to v8 is unchanged and kept below.

The question behind it: earlier versions of this card looked at what the pages say. An assistant or crawler also has to find the page that says it. Which pages does a visitor reach from the home page by following links inside the article text, and which only through the header and footer? And how well does a link's anchor text predict where it goes?

The headline findings:

• Almost all links are template links. 1,645 of 2,190 (75%) are in the header, nav or footer. Only 545 (25%) sit in the main content, and 496 of those point to another page on the site. The rest are 38 links to other sites and 11 e-mail links (mailto: or Cloudflare-obfuscated).
• 8 of the 40 pages have no inbound link from article text: /about/, /changelog/, /compare/, /dmca/, /explore/, /private-property-meme/, /state-property-meme/ and /this-is-private-property/. They are reachable (every page is within 2 clicks of the home page when you count header and footer links), but following only in-content links, none of the eight can be reached from / at all.
• 1,631 internal links are written without a trailing slash (for example /pricing). Of the 46 distinct slash-less hrefs, 44 answer with a 301 to the slash form and 2 (/memes and /memes/hit-the-road-dude) answer 200 directly. It works, but it spends a redirect on most clicks and means two URL forms circulate for some pages. Every internal link target returns 200 once normalised.
• Anchor text is a strong predictor. Predicting a link's target from its anchor text alone with a plain token-overlap rule is right 75.8% of the time over 48 candidates, against 2.0% for random and 14.3% for "always the home page".

Current facts as checked on 2026-11-13 (09:02 CST): one clip is 15 seconds, vertical 9:16, $9.99 at 480p (6 credits) or $12.99 at 720p (14 credits), with packs for signed-in accounts at $27.99/30, $71.99/100 and $129.99/200, one-time, no renewal (pricing). Prices are unchanged since 2026-11-03.

What this is not: no images, videos, faces, voices, generated outputs or user data. Link metadata only, from the site's own public HTML. One capture, taken by the builder of the site on 2026-11-13. It is not a crawl of the web, and it does not claim anything about how any search engine or assistant treats these links.

Who wrote it: the builder of hittheroaddude.app. Treat it as first-party.

Files (v9)

data/link-graph-2026-11-13.jsonl, one link per row:

Field	Meaning
id	hitt-lk-0001 … hitt-lk-2190
src	Page the link is on, as a canonical path (/guides/driver-photo/)
region	Innermost of main, footer, header, nav around the <a>. nav here means a navigation block that is not inside the header
anchor	Visible link text, whitespace collapsed (falls back to aria-label)
href	The href as written in the HTML
dst	Normalised target: internal paths end in /, query and fragment removed. External links are scheme://host/path
dst_kind	internal (2,141), external (38), other (11: mailto: and Cloudflare-obfuscated e-mail links)
in_content	true when region is main (545 rows)
dst_status	HTTP status of an internal target on 2026-11-13 (always 200); null for external and other
dst_redirect	Redirect target of the normalised dst, if any (always null here, because dst is already the slash form)
captured	2026-11-13

Same-page jumps (#faq) and self-links are dropped, and a link to /#how-it-works counts as a link to /. Example rows:

{"id": "hitt-lk-0002", "src": "/about/", "region": "header", "anchor": "Memes", "href": "/memes", "dst": "/memes/", "dst_kind": "internal", "in_content": false, "dst_status": 200, "dst_redirect": null, "captured": "2026-11-13"}
{"id": "hitt-lk-0016", "src": "/about/", "region": "main", "anchor": "Creator guides", "href": "/guides", "dst": "/guides/", "dst_kind": "internal", "in_content": true, "dst_status": 200, "dst_redirect": null, "captured": "2026-11-13"}

The tasks, and what leaks

1. Link prediction. Given src and anchor (and optionally the list of candidate targets), predict dst for the 496 in-content internal rows. dst, dst_status and href give the answer away; hide them.
2. Reachability. Which pages can be reached from / using only in-content links? The answer (all but 8 of 40, which take up to 3 clicks, and 8 not at all) is computed from the file.
3. Template-link filtering. Separate editorial links from template links using region alone, then ask whether an anchor-only classifier can do it without the region.

Validation and baselines (v9)

$ python3 validate_links.py
shape OK: 2190 rows
edges 2190 | internal 2141 | in-content (main) 545 | pages 40
by region: {'header': 547, 'main': 545, 'nav': 118, 'footer': 980}
pages with no in-content inbound link (8): /about/, /changelog/, /compare/, /dmca/, /explore/, /private-property-meme/, /state-property-meme/, /this-is-private-property/
depth from / via all links: max 2, unreached 0
depth from / via in-content links only: max 3, unreached 8 (/about/, /changelog/, /compare/, /dmca/, /explore/, /private-property-meme/, /state-property-meme/, /this-is-private-property/)
internal links written without a trailing slash: 1631 (e.g. /about, /acceptable-use, /account, /billing, /blog); ...
link prediction on 496 in-content internal edges (predict dst from anchor text), 48 candidate targets:
  random target                    accuracy 0.020
  always /                         accuracy 0.143
  anchor/slug token overlap        accuracy 0.758
live links vs file: 0 new, 0 gone across 40 pages
internal targets not returning 200 now: none
status of the slash-less hrefs as written (distinct hrefs by status): {301: 44, 200: 2}

How to read the baselines:

• "Always the home page" is the most-linked target in content (71 links), and still only 14.3%. The links are spread across 48 targets.
• Token overlap compares the words in the anchor ("Creator guides", "Help center", "Contact support") with the words in each candidate's path. It works because the site's anchors are plain descriptions. It fails when the anchor is a verb phrase ("Open the studio", "Read acceptable use") or a sentence fragment. Those are the interesting rows for a better model.
• A model that also sees the target page's title or summary, which this file doesn't include, should do much better. Fetching titles is an obvious extension.

#!/usr/bin/env python3
"""Validate data/link-graph-2026-11-13.jsonl, optionally re-fetch the live pages, and score link baselines.

usage: python3 validate_links.py [--offline]
  default   re-fetch every source page and compare its links with the file (needs network, ~40 requests),
            then re-check the status of every internal target
  --offline only check the file's shape and recompute the graph statistics and baselines
Standard library only. Needs link_graph_lib.py next to it.
"""
import argparse, collections, json, os, random, re, sys, urllib.request
from concurrent.futures import ThreadPoolExecutor
from link_graph_lib import extract_edges, probe, ORIGIN

HERE = os.path.dirname(os.path.abspath(__file__))
PATH = os.path.join(HERE, "data", "link-graph-2026-11-13.jsonl")
FIELDS = {"id", "src", "region", "anchor", "href", "dst", "dst_kind", "in_content", "dst_status", "dst_redirect", "captured"}


def load():
    rows = [json.loads(l) for l in open(PATH, encoding="utf-8")]
    ids = set()
    for r in rows:
        assert set(r) == FIELDS, (r["id"], set(r) ^ FIELDS)
        assert r["id"] not in ids; ids.add(r["id"])
        assert r["region"] in ("header", "nav", "main", "footer", "other")
        assert r["dst_kind"] in ("internal", "external", "asset", "other")
        assert r["in_content"] == (r["region"] == "main")
        assert (r["dst_status"] is not None) == (r["dst_kind"] == "internal")
        if r["dst_kind"] == "internal": assert r["dst"].startswith("/") and r["dst"].endswith("/") or "." in r["dst"]
    return rows


def graph_stats(rows):
    internal = [r for r in rows if r["dst_kind"] == "internal"]
    pages = sorted({r["src"] for r in rows})
    inb_all = collections.Counter(r["dst"] for r in internal)
    inb_content = collections.Counter(r["dst"] for r in internal if r["in_content"])
    print(f"edges {len(rows)} | internal {len(internal)} | in-content (main) {sum(r['in_content'] for r in rows)} | pages {len(pages)}")
    print("by region:", dict(collections.Counter(r["region"] for r in rows)))
    no_content_in = [p for p in pages if inb_content[p] == 0]
    print(f"pages with no in-content inbound link ({len(no_content_in)}):", ", ".join(no_content_in))
    # click depth from "/" using every link, and using in-content links only
    for label, edges in (("all links", internal), ("in-content links only", [r for r in internal if r["in_content"]])):
        adj = collections.defaultdict(set)
        for r in edges: adj[r["src"]].add(r["dst"])
        depth, q = {"/": 0}, ["/"]
        for u in q:
            for v in adj[u]:
                if v not in depth: depth[v] = depth[u] + 1; q.append(v)
        unreached = [p for p in pages if p not in depth]
        print(f"depth from / via {label}: max {max(depth.values())}, unreached {len(unreached)}" + (f" ({', '.join(unreached[:8])})" if unreached else ""))
    noslash = [r for r in internal if r["href"].split("#")[0].split("?")[0] not in ("", "/") and not r["href"].split("#")[0].endswith("/")]
    print(f"internal links written without a trailing slash: {len(noslash)} (e.g. {', '.join(sorted({r['href'] for r in noslash})[:5])}); "
          "whether such a URL answers 200 or redirects to the slash form is checked live below")
    return internal


def slug_tokens(s):
    return set(t for t in re.split(r"[^a-z0-9]+", s.lower()) if len(t) > 2)


def baselines(rows):
    ex = [r for r in rows if r["in_content"] and r["dst_kind"] == "internal"]
    targets = sorted({r["dst"] for r in rows if r["dst_kind"] == "internal"})
    top = collections.Counter(r["dst"] for r in ex).most_common(1)[0][0]
    rng = random.Random(0)
    def overlap(r):
        a = slug_tokens(r["anchor"])
        best = max(targets, key=lambda t: (len(a & slug_tokens(t)), t == top))
        return best
    res = {"random target": sum(rng.choice(targets) == r["dst"] for r in ex) / len(ex),
           f"always {top}": sum(top == r["dst"] for r in ex) / len(ex),
           "anchor/slug token overlap": sum(overlap(r) == r["dst"] for r in ex) / len(ex)}
    print(f"link prediction on {len(ex)} in-content internal edges (predict dst from anchor text), {len(targets)} candidate targets:")
    for k, v in res.items(): print(f"  {k:32} accuracy {v:.3f}")


def get(url, tries=5):
    for i in range(tries):
        try:
            return urllib.request.urlopen(urllib.request.Request(url, headers={"User-Agent": "link-graph/1.0"}), timeout=20).read().decode("utf-8", "replace")
        except OSError:
            if i == tries - 1: raise


def live_compare(rows):
    by_src = collections.defaultdict(list)
    for r in rows: by_src[r["src"]].append(r)
    key = lambda e: (e["region"], e["href"], e["anchor"])
    srcs = sorted(by_src)
    with ThreadPoolExecutor(8) as ex:                      # new connections can be slow; fetch in parallel
        pages = dict(zip(srcs, ex.map(lambda s: get(ORIGIN + s), srcs)))
        added = removed = 0
        for src in srcs:
            # 'other' = mailto / obfuscated e-mail links, whose href changes per request
            new = collections.Counter(key(e) for e in extract_edges(src, pages[src]) if e["dst_kind"] != "other")
            was = collections.Counter(key(e) for e in by_src[src] if e["dst_kind"] != "other")
            a, d = sum((new - was).values()), sum((was - new).values())
            added += a; removed += d
            if a or d: print(f"  {src}: +{a} -{d}")
        print(f"live links vs file: {added} new, {removed} gone across {len(by_src)} pages")
        targets = sorted({r["dst"] for r in rows if r["dst_kind"] == "internal"})
        bad = [(t, st) for t, (st, _) in zip(targets, ex.map(probe, targets)) if st != 200]
        print("internal targets not returning 200 now:", bad or "none")
        hrefs = sorted({r["href"].split("#")[0] for r in rows if r["dst_kind"] == "internal" and r["href"].startswith("/")
                        and not r["href"].split("#")[0].endswith("/")})
        codes = collections.Counter(st for st, _ in ex.map(probe, hrefs))
        print("status of the slash-less hrefs as written (distinct hrefs by status):", dict(codes))


if __name__ == "__main__":
    ap = argparse.ArgumentParser(); ap.add_argument("--offline", action="store_true"); a = ap.parse_args()
    rows = load(); print("shape OK:", len(rows), "rows")
    graph_stats(rows); baselines(rows)
    if not a.offline: live_compare(rows)

Using it

import json, collections
rows = [json.loads(l) for l in open("data/link-graph-2026-11-13.jsonl", encoding="utf-8")]
content_in = collections.Counter(r["dst"] for r in rows if r["in_content"] and r["dst_kind"] == "internal")
pages = {r["src"] for r in rows}
print("pages with no in-content inbound link:", sorted(p for p in pages if content_in[p] == 0))

Suggested uses: testing whether a retrieval pipeline that follows only in-content links can reach an answer page, auditing template-heavy small sites for orphaned pages, and training or evaluating anchor-text-to-URL models on a graph where every target is known to be live.

Limits

• One capture, one site, one day. A link graph from a different day, or a bigger site, may look different.
• main is the HTML element. It includes lists of cards and calls to action as well as prose, so "in-content" is not the same as "editorial".
• The 38 external links go to 9 hosts: knowyourmeme.com (8), the four similarly named Hit the Road Dude sites the compare and journal pages discuss (5 each) and four other sites run by the builder (10 in total). They are in the file because the pages contain them; they are not an endorsement or a claim about those sites.
• nav rows, 118, are navigation blocks outside the header, such as footer-adjacent menus. If you want only top navigation, use header.
• Link status is a plain GET without following redirects, from one network at one time.

Licence

CC BY 4.0. Page text and URLs belong to hittheroaddude.app, which is where they are published.

---

Earlier card (v8): page change history and stale-answer detection (Dataset Card v8, 2026-11-12)

What changed in v8 (2026-11-12): one new file and one script. data/page-history-2026-11-12.jsonl has 378 lines of text from 28 pages of hittheroaddude.app, each with the dates it was seen across 8 daily captures between 2026-11-02 and 2026-11-12, and a status: stable, added or removed. validate_history.py checks the file shape, re-fetches the pages' .md twins to confirm today's statuses still hold, and scores three simple baselines. Everything from v1 to v7 is unchanged and kept below. This upload also restores the v5 files (data/mentions-2026-11-09.jsonl, data/entities-2026-11-09.jsonl, link_baseline.py, validate_mentions.py) that the card has listed since 2026-11-09 but that were missing from the repo.

The question behind it: an assistant that read the site once and answers from memory will be confidently out of date when the site changes. Which lines of a small product site actually changed in ten days, and could you have predicted which ones would? v6 extracted prices from today's pages, and v7 checked third-party claims against them. v8 adds the time axis.

The headline finding: almost nothing changed, and what did change is exactly what an answer is most likely to quote. All 35 removed lines were last seen on 2026-11-02 and all 73 added lines were first seen on 2026-11-03. On 2026-11-02 the site disagreed with itself: the summary lines and the pricing page said 4.99 USD (480p, 1 credit) and 6.99 USD (720p, 2 credits), while the price table in the free-generator article and the body of the 480p-or-720p guide already said $9.99 and $12.99 (6 and 14 credits). From 2026-11-03 every page says $9.99 and $12.99. Pack prices ($27.99 for 30 credits, $71.99 for 100, $129.99 for 200) never changed. Several pages (about, blog index, guides index, compare) were rewritten the same day. Nothing in the 8 captures changed after 2026-11-03.

Current facts as checked on 2026-11-12 (08:57 CST): one clip is 15 seconds, vertical 9:16, $9.99 at 480p (6 credits) or $12.99 at 720p (14 credits), with packs for signed-in accounts at $27.99/30, $71.99/100 and $129.99/200, one-time, no renewal (pricing). An answer that still says $4.99 is quoting the 2026-11-02 page.

What this is not: no images, videos, faces, voices, generated outputs or user data. Text only, from the site's own public .md pages. The captures are mine, taken once a day by the builder of the site. They are not a crawl of the web, and they are not a log of what any assistant said.

Who wrote it: the builder of hittheroaddude.app. Treat it as first-party.

Files (v8)

data/page-history-2026-11-12.jsonl, one line of page text per row:

Field	Meaning
id	hitt-ph-001 … hitt-ph-378
page	Canonical path, e.g. /pricing/
md_url	The page's plain-text twin, used by the validator
text	One paragraph, heading, list item or table row, markdown markers stripped, 20+ characters. Canonical page:, Updated: and Published: lines are left out
status	stable (270): on every capture of that page. added (73): absent from the first capture, present on the latest. removed (35): absent from the latest capture
first_seen, last_seen	First and last capture dates containing the line
seen_on	Every capture date containing the line
page_captures	Every date that page was captured (5 to 8. Not every page was saved every day, and two pages were first captured on 2026-11-03)
has_price	The line contains a USD amount or a credit count
replaced_by	For 12 removed lines, the most similar added line on the same page (difflib ratio at least 0.6), else null

Example lines:

{"id": "hitt-ph-341", "page": "/pricing/", "md_url": "https://hittheroaddude.app/pricing.md", "text": "One clip is 4.99 USD at 480p or 6.99 USD at 720p. Credit packs require an account and start at 27.99 USD. There is no subscription.", "status": "removed", "first_seen": "2026-11-02", "last_seen": "2026-11-02", "seen_on": ["2026-11-02"], "page_captures": ["2026-11-02", "2026-11-03", "2026-11-04", "2026-11-05", "2026-11-09", "2026-11-10", "2026-11-11", "2026-11-12"], "has_price": true, "replaced_by": "One clip is 9.99 USD at 480p or 12.99 USD at 720p. Credit packs require an account and start at 27.99 USD. There is no subscription."}
{"id": "hitt-ph-343", "page": "/pricing/", "text": "Signed-in accounts can buy 27.99 USD for 30 credits, 71.99 USD for 100 credits, or 129.99 USD for 200 credits. Packs do not renew.", "status": "stable", "has_price": true, "...": "..."}

(The second line is shortened here; every row in the file has all 11 fields.)

The task, and what leaks

Task: given page, text and first_seen (the day an answer quoted the line), predict whether the line is still current on the latest capture (status != "removed").

seen_on, last_seen, status and replaced_by give the answer away. Hide them from a model under test. page_captures is safe.

Validation and baselines (v8)

$ python3 validate_history.py
378 rows, 28 pages, {'stable': 270, 'removed': 35, 'added': 73}
live check: 378/378 rows match the site today
baseline A: everything is still current      accuracy 343/378 = 90.7%  stale found 0/35, false alarms 0
baseline B: priced line first seen earliest  accuracy 345/378 = 91.3%  stale found 11/35, false alarms 9
baseline C: any line first seen earliest     accuracy 164/378 = 43.4%  stale found 35/35, false alarms 214

Read these carefully:

• A is the "trust your memory" assistant. 90.7% accurate, and it gets every price wrong. Accuracy is the wrong metric here. Count stale lines found.
• B ("prices from the first day are stale") catches all 11 removed price lines, but also flags 9 lines that were right all along: pack prices, and the lines that already showed $9.99/$12.99 on 2026-11-02. Prices are volatile, but not all of them moved. When a page contradicts itself, a model has to pick the right half.
• C ("anything old is stale") catches everything by flagging 57% of the site.
• The 24 removed lines without a price are wording rewrites (the about page, the blog and guides indexes, the compare table). Their meaning is mostly unchanged, so missing them costs little. This set doesn't label meaning-level change. That's a good extension.

#!/usr/bin/env python3
"""Check data/page-history-2026-11-12.jsonl against the live site, then score two baselines.

python3 validate_history.py            # fetches the .md twins (about 25 requests)
python3 validate_history.py --offline  # schema and baselines only
Standard library only.
"""
import collections, json, re, sys, urllib.request

FILE = "data/page-history-2026-11-12.jsonl"
STATUSES = {"stable", "added", "removed"}
KEYS = {"id", "page", "md_url", "text", "status", "first_seen", "last_seen", "seen_on",
        "page_captures", "has_price", "replaced_by"}
norm = lambda s: re.sub(r"\s+", " ", s).strip()

rows = [json.loads(l) for l in open(FILE, encoding="utf-8")]
for r in rows:
    assert set(r) == KEYS, (r["id"], set(r) ^ KEYS)
    assert r["status"] in STATUSES, r["id"]
    assert r["seen_on"] == sorted(r["seen_on"]) and r["first_seen"] == r["seen_on"][0] and r["last_seen"] == r["seen_on"][-1], r["id"]
    assert set(r["seen_on"]) <= set(r["page_captures"]), r["id"]
    current = r["page_captures"][-1] in r["seen_on"]
    assert current == (r["status"] != "removed"), r["id"]
    assert r["replaced_by"] is None or r["status"] == "removed", r["id"]
print(f"{len(rows)} rows, {len({r['page'] for r in rows})} pages,", dict(collections.Counter(r["status"] for r in rows)))

if "--offline" not in sys.argv:
    live, bad = {}, []
    for url in sorted({r["md_url"] for r in rows}):
        with urllib.request.urlopen(urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"}), timeout=30) as resp:
            live[url] = norm(resp.read().decode("utf-8"))
    for r in rows:
        on_page = norm(r["text"]) in live[r["md_url"]]
        if on_page != (r["status"] != "removed"):
            bad.append((r["id"], r["status"], "now on page" if on_page else "gone from page", r["text"][:70]))
    for b in bad:
        print("DRIFT", *b)
    print(f"live check: {len(rows) - len(bad)}/{len(rows)} rows match the site today")

# Task: given page, text and first_seen (the day an answer quoted it), is the line still current?
gold = [r["status"] != "removed" for r in rows]
def score(name, pred):
    ok = sum(p == g for p, g in zip(pred, gold))
    tp = sum((not p) and (not g) for p, g in zip(pred, gold)); fn = sum(p and (not g) for p, g in zip(pred, gold))
    fp = sum((not p) and g for p, g in zip(pred, gold))
    print(f"{name:44} accuracy {ok}/{len(rows)} = {ok / len(rows):.1%}  stale found {tp}/{tp + fn}, false alarms {fp}")
score("baseline A: everything is still current", [True] * len(rows))
earliest = min(r["first_seen"] for r in rows)
score("baseline B: priced line first seen earliest", [not (r["has_price"] and r["first_seen"] == earliest) for r in rows])
score("baseline C: any line first seen earliest", [r["first_seen"] != earliest for r in rows])
# seen_on, last_seen, status and replaced_by give the answer away: hide them from a model under test.

Using it

import json
rows = [json.loads(l) for l in open("data/page-history-2026-11-12.jsonl", encoding="utf-8")]
stale_prices = [r for r in rows if r["status"] == "removed" and r["has_price"]]
for r in stale_prices:
    print(r["page"], "|", r["text"][:60], "->", (r["replaced_by"] or "(rewritten)")[:60])

Suggested uses: testing whether a retrieval-augmented assistant prefers the current line over a cached one, building "this may be out of date" warnings for price answers, and checking diff-and-recrawl heuristics on a small site where every change is known.

Limits

• 8 captures and one real change event. It's a probe, not a benchmark. Splits are not provided.
• Line-level matching is exact after whitespace collapse. A one-word edit makes one removed and one added row. replaced_by links 12 of those pairs.
• Captures are daily at most and have gaps (no captures on 2026-11-06 to 11-08, and some pages missing on 2026-11-10). A change made and reverted between captures is invisible.
• The pages quote other sites' prices as checked on 2026-11-02. Those rows are this site's text, not verified prices of those sites.

Licence

CC BY 4.0. Page text belongs to hittheroaddude.app, which is where it is published.

---

Earlier card (v7): assistant-claim verification (Dataset Card v7, 2026-11-11)

What changed in v7 (2026-11-11): one new file and one script. data/claims-2026-11-11.jsonl has 40 short claims of the kind an AI assistant might make when asked about the Hit the Road Dude meme or hittheroaddude.app, each labelled SUPPORTED, REFUTED or NOT_ON_SITE against one evidence sentence quoted from the site. validate_claims.py checks the schema, re-fetches the pages, confirms every evidence quote is still live, and scores a three-rule baseline. Everything from v1 to v6 is unchanged and kept below.

The question behind it: when an assistant answers "Is the Hit the Road Dude AI generator free?" or "Does it use the original audio?", is what it says true according to the site it's describing? v4 asked whether the site's own pages agree with each other. v7 asks whether a third party's statement about the site holds up, FEVER-style: claim, evidence, verdict.

What makes it hard despite being small:

• Numbers that are close. "One 720p clip costs $14.99" and "One 480p clip costs $9.99" share the same evidence sentence and get opposite labels.
• Negation on both sides. "The finished file has a watermark unless you pay extra" is refuted by "the studio does not add a watermark to the finished file"; the Japanese claim 「完成した動画には透かしが入らない。」 (no watermark) is supported by the same sentence.
• Refutation by a broader rule. "You can choose a 30-second version" is refuted by "You do not pick a length, framing, or voice", which contains no number.
• Unknown is not false. "The pond in the original video is in Texas" gets NOT_ON_SITE, because the evidence says the location "is not established here". "Uploaded photos are deleted after 24 hours" is NOT_ON_SITE because the privacy page publishes no retention period.
• Support without the keyword. "A dog or a cat can be the driver" is supported by "There is no separate pet mode. The same preset takes a person or a pet; the photo decides who drives."

Facts as checked on 2026-11-11 (09:00 CST): one clip is 15 seconds, vertical 9:16, at $9.99 for 480p (6 credits) or $12.99 for 720p (14 credits). Credit packs for signed-in accounts are $27.99 for 30 credits, $71.99 for 100 and $129.99 for 200, one-time, no renewal. No free clip, no prompt, no model choice, a newly generated voice rather than the original recording, no watermark added. These are what the labels rest on; the validator tells you if a page changes.

What this is not: no images, videos, faces, voices, generated outputs or user data. The claims were written by me to resemble assistant answers. They are not logged outputs of any particular assistant.

Who wrote it: the builder of hittheroaddude.app. The labels are my reading of my own pages. Treat it as first-party.

Files (v7)

data/claims-2026-11-11.jsonl, one claim per line:

Field	Meaning
id	hitt-cl-001 … hitt-cl-040
lang	Language of the claim: 36 en, one each zh, es, de, ja. Evidence is always English
claim	A short statement about the meme or the studio
label	SUPPORTED (12), REFUTED (24) or NOT_ON_SITE (4)
evidence_page	The page the evidence is quoted from: an .md twin, or the HTML FAQ for one row
evidence_quote	Exact text on that page after whitespace is collapsed
note	Topic, plus what makes the row easy or hard
checked	2026-11-11

Evidence comes from 16 pages; the most used are the FAQ, the 480p-or-720p guide, the free-generator article and the about page (four rows each).

Example lines:

{"id": "hitt-cl-007", "lang": "en", "claim": "One 720p clip costs $14.99.", "label": "REFUTED", "evidence_page": "https://hittheroaddude.app/pricing.md", "evidence_quote": "480p is 9.99 USD (6 credits). 720p is 12.99 USD (14 credits).", "note": "price; same evidence as the supported row, wrong number", "checked": "2026-11-11"}
{"id": "hitt-cl-030", "lang": "en", "claim": "Uploaded photos are deleted after 24 hours.", "label": "NOT_ON_SITE", "evidence_page": "https://hittheroaddude.app/privacy.md", "evidence_quote": "The studio stores your account email, a password hash, your uploaded photo for the clip you ordered, and order records.", "note": "retention; no period is published", "checked": "2026-11-11"}
{"id": "hitt-cl-040", "lang": "ja", "claim": "完成した動画には透かしが入らない。", "label": "SUPPORTED", "evidence_page": "https://hittheroaddude.app/blog/is-hit-the-road-dude-ai-free.md", "evidence_quote": "the studio does not add a watermark to the finished file", "note": "watermark; Japanese claim, negated claim supported by negated evidence", "checked": "2026-11-11"}

Two judgement calls worth flagging:

• hitt-cl-019, HEIC uploads, is NOT_ON_SITE. The photo guide lists JPEG, PNG or WebP and doesn't mention HEIC. A closed-world reader would call the claim refuted. I didn't, because no page says HEIC is rejected, and some phone browsers convert HEIC on upload.
• hitt-cl-016, the parrot, is REFUTED. The evidence is hedged ("may look less like your pet"), but it contradicts "exactly".

Validation and baseline (v7)

$ python3 validate_claims.py
40 rows, 16 pages, evidence all live; {'SUPPORTED': 12, 'REFUTED': 24, 'NOT_ON_SITE': 4}
baseline miss hitt-cl-015 [en] gold SUPPORTED   pred REFUTED     A dog or a cat can be the driver.
baseline miss hitt-cl-016 [en] gold REFUTED     pred SUPPORTED   A parrot photo will look exactly like your parrot in the cli
baseline miss hitt-cl-017 [en] gold REFUTED     pred SUPPORTED   A group photo with several friends gives the best result.
baseline miss hitt-cl-019 [en] gold NOT_ON_SITE pred SUPPORTED   HEIC photos straight from an iPhone are accepted.
baseline miss hitt-cl-030 [en] gold NOT_ON_SITE pred REFUTED     Uploaded photos are deleted after 24 hours.
baseline miss hitt-cl-034 [en] gold NOT_ON_SITE pred SUPPORTED   A clip takes about two minutes to generate.
baseline miss hitt-cl-035 [en] gold REFUTED     pred SUPPORTED   hittheroaddude.app is the same site as hittheroaddude.org.
baseline miss hitt-cl-040 [ja] gold SUPPORTED   pred REFUTED     完成した動画には透かしが入らない。
rule baseline: 32/40 correct (English 29/36, other languages 3/4)
  gold NOT_ON_SITE -> NOT_ON_SITE 1, REFUTED 1, SUPPORTED 2
  gold REFUTED     -> NOT_ON_SITE 0, REFUTED 21, SUPPORTED 3
  gold SUPPORTED   -> NOT_ON_SITE 0, REFUTED 2, SUPPORTED 10

The baseline has three rules and no model: "not established / not published / does not say" in the evidence means NOT_ON_SITE; a negation present on one side but not the other, or a number in the claim that the evidence lacks, means REFUTED; anything else is SUPPORTED. With 24 of 40 rows refuted, that is roughly what a negation detector gets for free.

Read the 32/40 with care. The three non-English hits are mostly luck: the negation rule only sees English words, so the Chinese "free" claim is called REFUTED because the evidence has "no" in it, which happens to be right. The misses are the interesting rows: support that arrives through a negation (015), contradiction without a negation (016, 017, 035) and every NOT_ON_SITE row but one, since "not published" is rarely written down. It had no tuning on the data.

#!/usr/bin/env python3
"""Check the claim-verification set: schema, every evidence quote still live, then score a rule baseline.

usage: python3 validate_claims.py   (standard library only; network needed)
Evidence pages are the .md twins (https://hittheroaddude.app/<page>.md) or the visible text of an HTML page.
"""
import collections, html, json, re, sys, urllib.request

LABELS = {"SUPPORTED", "REFUTED", "NOT_ON_SITE"}
FIELDS = {"id", "lang", "claim", "label", "evidence_page", "evidence_quote", "note", "checked"}

def fetch(url):
    req = urllib.request.Request(url, headers={"User-Agent": "dataset-validator/1.0"})
    with urllib.request.urlopen(req, timeout=30) as r:
        t = r.read().decode("utf-8", "replace")
    if url.endswith("/"):                                   # HTML page -> visible text
        t = re.sub(r"<(script|style|svg)[^>]*>.*?</\1>", " ", t, flags=re.S)
        t = html.unescape(re.sub(r"<[^>]+>", " ", t))
    return re.sub(r"\s+", " ", t)

NEG = re.compile(r"\b(no|not|never|nothing|none|cannot)\b|n't\b|\bdo not\b", re.I)
UNKNOWN = re.compile(r"not established|not published|does not say", re.I)
NUM = re.compile(r"\d+(?:\.\d+)?")

def baseline(claim, quote):
    """Three rules, no model: 'unknown' wording -> NOT_ON_SITE; negation mismatch or a number
    in the claim that the quote lacks -> REFUTED; otherwise SUPPORTED."""
    if UNKNOWN.search(quote):
        return "NOT_ON_SITE"
    if bool(NEG.search(claim)) != bool(NEG.search(quote)):
        return "REFUTED"
    if any(n not in quote for n in NUM.findall(claim)):
        return "REFUTED"
    return "SUPPORTED"

def main():
    rows = [json.loads(l) for l in open("data/claims-2026-11-11.jsonl", encoding="utf-8")]
    ids = [r["id"] for r in rows]; assert len(ids) == len(set(ids)), "duplicate ids"
    for r in rows:
        assert set(r) == FIELDS, (r["id"], set(r) ^ FIELDS)
        assert r["label"] in LABELS, r["id"]
    pages, bad = {}, 0
    for r in rows:
        pages.setdefault(r["evidence_page"], fetch(r["evidence_page"]))
        if r["evidence_quote"] not in pages[r["evidence_page"]]:
            print("MISSING QUOTE", r["id"], r["evidence_quote"][:70]); bad += 1
    labels = collections.Counter(r["label"] for r in rows)
    print(f"{len(rows)} rows, {len(pages)} pages, evidence {'all live' if not bad else str(bad) + ' missing'}; {dict(labels)}")
    conf = collections.Counter(); hits = collections.Counter()
    for r in rows:
        p = baseline(r["claim"], r["evidence_quote"]); conf[(r["label"], p)] += 1
        hits[r["lang"] == "en", p == r["label"]] += 1
        if p != r["label"]:
            print(f"baseline miss {r['id']} [{r['lang']}] gold {r['label']:11s} pred {p:11s} {r['claim'][:60]}")
    ok = sum(v for (g, p), v in conf.items() if g == p)
    print(f"rule baseline: {ok}/{len(rows)} correct "
          f"(English {hits[True, True]}/{hits[True, True] + hits[True, False]}, "
          f"other languages {hits[False, True]}/{hits[False, True] + hits[False, False]})")
    for g in sorted(LABELS):
        print(f"  gold {g:11s} -> " + ", ".join(f"{p} {conf[g, p]}" for p in sorted(LABELS)))
    sys.exit(1 if bad else 0)

if __name__ == "__main__":
    main()

Using it

import json
rows = [json.loads(l) for l in open("data/claims-2026-11-11.jsonl", encoding="utf-8")]
unknown = [r for r in rows if r["label"] == "NOT_ON_SITE"]
print(len(rows), len(unknown))

Suggested uses: checking that an assistant grounded on these pages refuses to invent a retention period or a generation time; testing NLI models on negated support; a tiny multilingual sanity check with English evidence.

Limits

• 40 rows from one site is a probe, not a benchmark. Splits are not provided.
• Labels depend on the pages as they were on 2026-11-11; validate_claims.py shows when evidence has moved or changed.
• One evidence sentence per claim. Some claims could be settled by several pages; I picked the clearest.
• The claims are written to look like assistant output, not collected from real assistants.

Licence

CC BY 4.0. Evidence text belongs to hittheroaddude.app, which is where it is published.

---

Earlier card (v6): price-quote extraction (Dataset Card v6, 2026-11-10)

What changed in v6 (2026-11-10): one new file and one script. data/price-quotes-2026-11-10.jsonl has 28 quote snippets copied from five pages of hittheroaddude.app. Each carries the dollar amounts and credit counts a careful reader would extract. validate_price_quotes.py re-fetches the pages, confirms every quote is still on the live page, and scores a two-regex baseline. Everything from v1 to v5 is unchanged and kept below.

The question behind it: can an assistant read a price out of a page without mixing up numbers that look similar? The pricing page of this studio is a good small test, because one sentence can hold a price, a credit count, a run count and a competitor's price:

• "$5.60 per run" is a derived price per run, not a pack price.
• "about 5 Hit the Road Dude runs (5–30 across 7 memes)" contains numbers that are run counts, not credits.
• "Packs hold 30, 100 or 200 credits" shares one unit word across three numbers.
• "a 480p clip spends 6 credits and a 720p clip 14" has a credit count with no unit word.
• "hittheroaddude.org (11-second clips, adult-portrait packs from USD 6.99)" is another site's price, listed on this site's FAQ.
• "JPEG, PNG or WebP up to 10 MB" is a number with a unit that is not money.

Facts as checked on 2026-11-10 (09:00 CST): one clip is $9.99 at 480p (6 credits) or $12.99 at 720p (14 credits). Credit packs for signed-in accounts are $27.99 for 30 credits, $71.99 for 100 and $129.99 for 200. The pricing page also lists a derived price per run ($5.60, $4.50 and $3.94) and what each of the seven memes on the site costs. These are the values the gold labels use. They can change; the validator tells you.

What this is not: no images, videos, faces, voices, generated outputs or user data. It is not a record of what customers paid, only of what the pages publish.

Who wrote it: the builder of hittheroaddude.app. The labels are my judgement about which numbers are prices and credit counts. Treat it as first-party.

Files (v6)

data/price-quotes-2026-11-10.jsonl, one quote per line:

Field	Meaning
id	hitt-pq-001 … hitt-pq-028
page	Page the quote comes from: the .md twin where one exists, otherwise the HTML page's visible text
quote	Exact text as it appears on that page after whitespace is collapsed
prices_usd	Dollar amounts in the quote that are prices of something (empty if none)
credits	Credit amounts in the quote (empty if none)
fact_type	Single price, credit packs, per-run derived, other meme row, other site price, not a price, and so on (15 types)
note	Why the row is easy or hard
checked	2026-11-10

Counts: 11 rows from /pricing/, 9 from /faq/, 5 from pricing.md, 2 from guides.md, 1 from the home page. Four are other memes on the same price table, three are other sites' prices, and three are per-run derived prices.

Example lines:

{"id": "hitt-pq-003", "page": "https://hittheroaddude.app/pricing.md", "quote": "Signed-in accounts can buy 27.99 USD for 30 credits, 71.99 USD for 100 credits, or 129.99 USD for 200 credits.", "prices_usd": [27.99, 71.99, 129.99], "credits": [30, 100, 200], "fact_type": "credit_packs", "note": "three packs, USD after the number", "checked": "2026-11-10"}
{"id": "hitt-pq-013", "page": "https://hittheroaddude.app/pricing/", "quote": "30 credits · about 5 Hit the Road Dude runs (5–30 across 7 memes) · $5.60 per run", "prices_usd": [5.6], "credits": [30], "fact_type": "per_run_derived", "note": "'about 5' and '5–30' are run counts, not credits", "checked": "2026-11-10"}
{"id": "hitt-pq-026", "page": "https://hittheroaddude.app/faq/", "quote": "hittheroaddude.org (11-second clips, adult-portrait packs from USD 6.99)", "prices_usd": [6.99], "credits": [], "fact_type": "other_site_price", "note": "a competitor's listed price, not this studio's", "checked": "2026-11-10"}

A judgement call worth flagging: other sites' prices are included in prices_usd. The task is extraction of dollar amounts. Whether the amount belongs to this studio is what fact_type and the page context are for, and a stricter task would label it separately.

Validation and baseline (v6)

$ python3 validate_price_quotes.py
28 rows, 5 pages, quotes all live
baseline miss hitt-pq-005 {'prices': [], 'credits': [6]} gold [] [6, 14]
baseline miss hitt-pq-009 {'prices': [], 'credits': [6]} gold [] [6, 14]
baseline miss hitt-pq-016 {'prices': [], 'credits': [200]} gold [] [30, 100, 200]
baseline miss hitt-pq-023 {'prices': [], 'credits': []} gold [] [30, 100, 200, 6, 14]
baseline miss hitt-pq-026 {'prices': [], 'credits': []} gold [6.99] []
baseline miss hitt-pq-027 {'prices': [], 'credits': []} gold [6.9] []
baseline miss hitt-pq-028 {'prices': [], 'credits': []} gold [9.9] []
regex baseline: prices 25/28, credits 24/28

The baseline is two regexes: dollar amounts as $9.99 or 9.99 USD, and credits as a number followed by "credit(s)". It fails in two predictable ways. It misses a number with no unit word ("a 720p clip 14") and a list that shares a unit ("30, 100 or 200 credits"). It also misses prices written USD 6.99, because it only knows the $9.99 and 9.99 USD orders. All seven misses are hard-by-construction, so the 25/28 and 24/28 are a floor for a modest approach, not a leaderboard. It had no tuning on the data. These are exact-match scores per row, not per number.

#!/usr/bin/env python3
"""Check the price-quote dataset: every quote is still on the live page, then score a regex baseline.

usage: python3 validate_price_quotes.py   (standard library only; network needed)
Pages are read as the .md twins (https://hittheroaddude.app/<page>.md) or as visible text of the HTML page.
"""
import html, json, re, sys, urllib.request

def fetch(url):
    req = urllib.request.Request(url, headers={"User-Agent": "dataset-validator/1.0"})
    with urllib.request.urlopen(req, timeout=30) as r:
        t = r.read().decode("utf-8", "replace")
    if url.endswith("/"):                                   # HTML page -> visible text
        t = re.sub(r"<(script|style|svg)[^>]*>.*?</\1>", " ", t, flags=re.S)
        t = html.unescape(re.sub(r"<[^>]+>", " ", t))
    return re.sub(r"\s+", " ", t)

MONEY = re.compile(r"(?:\$\s?(\d+(?:\.\d+)?)|(\d+(?:\.\d+)?)\s?USD)")
CREDITS = re.compile(r"(\d+)\s+credits?")

def baseline(quote):
    """Return {'prices': [...], 'credits': [...]} using two regexes, nothing smarter."""
    prices = [float(a or b) for a, b in MONEY.findall(quote)]
    return {"prices": prices, "credits": [int(c) for c in CREDITS.findall(quote)]}

def main():
    rows = [json.loads(l) for l in open("data/price-quotes-2026-11-10.jsonl", encoding="utf-8")]
    ids = [r["id"] for r in rows]; assert len(ids) == len(set(ids)), "duplicate ids"
    pages, bad = {}, 0
    for r in rows:
        pages.setdefault(r["page"], fetch(r["page"]))
        if r["quote"] not in pages[r["page"]]:
            print("MISSING QUOTE", r["id"], r["quote"][:70]); bad += 1
    print(f"{len(rows)} rows, {len(pages)} pages, quotes {'all live' if not bad else str(bad) + ' missing'}")
    hit_p = hit_c = 0
    for r in rows:
        b = baseline(r["quote"])
        okp = sorted(b["prices"]) == sorted(r["prices_usd"]); okc = sorted(b["credits"]) == sorted(r["credits"])
        hit_p += okp; hit_c += okc
        if not (okp and okc): print("baseline miss", r["id"], b, "gold", r["prices_usd"], r["credits"])
    print(f"regex baseline: prices {hit_p}/{len(rows)}, credits {hit_c}/{len(rows)}")
    sys.exit(1 if bad else 0)

if __name__ == "__main__":
    main()

Using it

import json
rows = [json.loads(l) for l in open("data/price-quotes-2026-11-10.jsonl", encoding="utf-8")]
hard = [r for r in rows if r["fact_type"] in {"per_run_derived", "other_site_price", "not_a_price", "comparison_table"}]
print(len(rows), len(hard))

Suggested uses: evaluating extraction of numbers from small web pages, testing that a model keeps run counts and credit counts apart, and checking that "from USD X" for another site is not attributed to this one.

Limits

• 28 rows from one site is a probe, not a benchmark. Splits are not provided.
• Prices change. The quotes were live on 2026-11-10; validate_price_quotes.py shows when one has not been.
• The .md twins and the visible text of the HTML pages may differ slightly in wording; each row names which one it used.

Licence

CC BY 4.0. Quote text belongs to hittheroaddude.app, which is where it is published.

---

Earlier card (v5): entity-linking mentions (v5)

What changed in v5 (2026-11-09): two new files and two scripts. data/mentions-2026-11-09.jsonl has 36 short search-style mentions in six languages. Each is labelled with the entity it refers to. data/entities-2026-11-09.jsonl describes the 5 candidate entities, with evidence URLs. link_baseline.py runs three baselines, and validate_mentions.py checks the file shape and confirms the alias evidence is still live. The v4 NLI pairs, v3 routing set, v2 decision cases and v1 Q&A snapshot are unchanged and still load as their own configs.

The question behind it: when someone types "state property" or "hit the road" into an assistant, which thing do they mean? The pickup-window meme from hittheroaddude.app shares words with two well-known works and one everyday concept:

Entity id	What it is	Evidence
hitt_state_property_clip	The State Property pickup-window clip: a driver repeats "State?", says it's private property, and ends with "hit the road, dude". Also called State Property meme, Private Property meme, This Is Private Property; Know Your Meme title "Lock 'Em Up / State Property"	names page, home
hit_the_road_jack_song	"Hit the Road Jack", written by Percy Mayfield and recorded by Ray Charles, a US number 1 in 1961	Wikipedia
state_property_2002_film	State Property, a 2002 crime film starring Beanie Sigel, produced by Roc-A-Fella; sequel in 2005	Wikipedia
private_property_generic	Private property as a general idea: signs, trespassing, land questions	none needed
none	Too short or ambiguous to link without more context	none

A keyword shortcut gets this badly wrong. "Hit the road jack lyrics" isn't a meme request, and "state property beanie sigel" isn't one either.

What this is not: there are no images, videos, faces, voices, generated outputs or user data. The person in the original viral video is a private individual, and nothing here names him.

Who wrote it: the builder of hittheroaddude.app. The labels are my judgement, and two rows (none) are deliberately ambiguous. Treat it as first-party.

Files (v5)

data/mentions-2026-11-09.jsonl, one mention per line:

Field	Meaning
id	hitt-el-001 … hitt-el-036
mention	The text as someone might type it
lang	en (26), zh (4), es (3), pt, de, ja (1 each)
entity	hitt_state_property_clip (19), hit_the_road_jack_song (7), state_property_2002_film (5), private_property_generic (3), none (2)
rationale	Why the label holds, in a few words
checked	2026-11-09

Example lines:

{"id": "hitt-el-004", "mention": "state property meme old man truck", "lang": "en", "entity": "hitt_state_property_clip", "rationale": "truck + meme context", "checked": "2026-11-09"}
{"id": "hitt-el-017", "mention": "hit the road jack meme", "lang": "en", "entity": "hit_the_road_jack_song", "rationale": "names the song; the clip has no music", "checked": "2026-11-09"}
{"id": "hitt-el-026", "mention": "state property", "lang": "en", "entity": "none", "rationale": "ambiguous: film or meme without context", "checked": "2026-11-09"}

data/entities-2026-11-09.jsonl contains entity, description and evidence (a list of URLs).

A judgement call worth flagging: "hit the road jack meme" is labelled as the song. Someone who names Jack is asking about the song, even when they add "meme". The clip itself has no music, and the studio "does not add that song or any music track" (names page).

Validation (v5)

$ python3 validate_mentions.py
36 rows, 5 labels, shape ok
ok   https://hittheroaddude.app/blog/names-not-the-song.md :: State Property meme, Private Property meme, and This Is Priv
ok   https://hittheroaddude.app/blog/names-not-the-song.md :: It is not the song Hit the Road Jack
ok   https://hittheroaddude.app/index.md :: Lock 'Em Up / State Property
200 https://en.wikipedia.org/wiki/Hit_the_Road_Jack
200 https://en.wikipedia.org/wiki/State_Property_(film)

#!/usr/bin/env python3
"""Check the dataset file shape, and that the alias evidence is still live.

Re-fetches the two site pages and confirms each quoted alias sentence is
still there, then confirms the Wikipedia pages still return 200.
Standard library only; network needed for the second part.
"""
import json, sys, urllib.request

ALLOWED = {"hitt_state_property_clip", "hit_the_road_jack_song",
           "state_property_2002_film", "private_property_generic", "none"}
QUOTES = {
    "https://hittheroaddude.app/blog/names-not-the-song.md": [
        "State Property meme, Private Property meme, and This Is Private Property name the same exchange here.",
        "It is not the song Hit the Road Jack",
    ],
    "https://hittheroaddude.app/index.md": ["Lock 'Em Up / State Property"],
}

def fetch(url):
    req = urllib.request.Request(url, headers={"User-Agent": "dataset-validator/1.0"})
    with urllib.request.urlopen(req, timeout=30) as r:
        return r.status, r.read().decode("utf-8", "replace")

def main():
    bad = 0
    rows = [json.loads(l) for l in open("data/mentions-2026-11-09.jsonl", encoding="utf-8")]
    ids = [r["id"] for r in rows]
    assert len(ids) == len(set(ids)), "duplicate ids"
    for r in rows:
        if r["entity"] not in ALLOWED or not r["mention"].strip():
            print("bad row", r["id"]); bad += 1
    print(f"{len(rows)} rows, {len(ALLOWED)} labels, shape {'ok' if not bad else 'BAD'}")
    for url, quotes in QUOTES.items():
        status, text = fetch(url)
        for q in quotes:
            ok = q in text
            bad += not ok
            print(f"{'ok  ' if ok else 'MISS'} {url} :: {q[:60]}")
    for e in (json.loads(l) for l in open("data/entities-2026-11-09.jsonl", encoding="utf-8")):
        for url in e["evidence"]:
            if "wikipedia" in url:
                status, _ = fetch(url)
                bad += status != 200
                print(f"{status} {url}")
    sys.exit(1 if bad else 0)

if __name__ == "__main__":
    main()

Baselines (v5)

#!/usr/bin/env python3
"""Three baselines for data/mentions-2026-11-09.jsonl.

  naive   : "hit the road" / "state property" / "private property" anywhere
            -> the meme. The shortcut a keyword router takes.
  lexical : character 3-gram cosine between the mention and each entity
            description; below 0.12 similarity -> "none".
  cues    : a hand-written ordered cue list. It was written while looking at
            these 36 rows, so its score is an upper bound, not a result.
Prints accuracy per baseline and every miss. Standard library only.
"""
import collections, json, math, re

def grams(s, n=3):
    s = " " + re.sub(r"\s+", " ", s.lower()) + " "
    return collections.Counter(s[i:i + n] for i in range(len(s) - n + 1))

def cos(a, b):
    dot = sum(a[k] * b[k] for k in a if k in b)
    na = math.sqrt(sum(v * v for v in a.values())); nb = math.sqrt(sum(v * v for v in b.values()))
    return dot / (na * nb) if na and nb else 0.0

def lexical(m, ents):
    g = grams(m)
    best = max(ents, key=lambda e: cos(g, grams(e["description"])))
    return best["entity"] if cos(g, grams(best["description"])) >= 0.12 and best["entity"] != "none" else "none"

CUES = [  # (entity, any-of substrings), first hit wins
    ("hit_the_road_jack_song", ["jack"]),
    ("state_property_2002_film", ["2002", "beanie", "sigel", "sequel", "roc-a-fella", "电影", "movie", "film"]),
    ("hitt_state_property_clip", ["dude", "meme", "梗", "ミーム", "state?", "tiktok", "pickup", "皮卡",
                                  "camioneta", "lock em up"]),
    ("private_property_generic", ["sign", "law", "trespass", "land"]),
]
def naive(m):
    s = m.lower()
    return ("hitt_state_property_clip"
            if any(k in s for k in ("hit the road", "state property", "private property", "私人财产"))
            else "none")

def cues(m):
    s = m.lower()
    for ent, keys in CUES:
        if any(k in s for k in keys):
            return ent
    return "none"

if __name__ == "__main__":
    rows = [json.loads(l) for l in open("data/mentions-2026-11-09.jsonl", encoding="utf-8")]
    ents = [json.loads(l) for l in open("data/entities-2026-11-09.jsonl", encoding="utf-8")]
    for name, fn in (("naive", naive), ("lexical", lambda m: lexical(m, ents)), ("cues", cues)):
        miss = [(r["id"], r["mention"], r["entity"], p) for r in rows if (p := fn(r["mention"])) != r["entity"]]
        print(f"{name:8} accuracy {len(rows) - len(miss)}/{len(rows)} = {1 - len(miss) / len(rows):.2f}")
        for i, m, gold, pred in miss:
            print(f"   {i}  {m!r:48} gold={gold:26} pred={pred}")

$ python3 link_baseline.py
naive    accuracy 17/36 = 0.47
lexical  accuracy 21/36 = 0.58
cues     accuracy 36/36 = 1.00

How to read these:

• naive (0.47) sends anything containing "hit the road", "state property" or "private property" to the meme. It gets every song, film and generic-property mention wrong, plus both ambiguous rows. It also misses ""State?" guy in the white pickup" and the Spanish "meme propiedad privada camioneta blanca", because neither contains the English phrases.
• lexical (0.58) compares character trigrams with the entity descriptions. It sends most "hit the road dude …" mentions to the song, because the song's short description is dominated by "Hit the Road". It also sends "private property sign printable" to the meme, because the meme's description is the one full of "private property". Short descriptions make lexical linking fragile.
• cues (1.00) is not a result. I wrote the cue list while looking at these 36 rows. It shows that a few ordered rules ("jack" first, then film cues, then meme cues) can separate the classes, and that's all it shows. A fair test needs new mentions written by someone else.

With 36 rows, every number here is anecdotal. The value is a small, dated, re-checkable set of hard negatives for anyone building search, routing or an answer engine around this meme.

Uses (v5)

• Hard negatives for retrieval. Pair each hitt_state_property_clip mention with the song and film mentions as negatives.
• Answer checking. An assistant asked "state property 2002 cast" shouldn't answer with a meme generator. One asked "make my dog say hit the road dude" shouldn't answer with Ray Charles.
• A template for any meme whose name collides with older works.

Loading with no dependencies:

import json
rows = [json.loads(l) for l in open("data/mentions-2026-11-09.jsonl", encoding="utf-8")]
print(len(rows), sum(r["entity"] == "none" for r in rows))

With 🤗 datasets: load_dataset("conan123/hittheroaddude-guides", "mentions"), plus "entities", "nli_pairs", "query_routing", "pages", "decision_cases" and "qa_2026_11_02".

Product facts, for context (checked 2026-11-09)

From the live pricing page: one clip is 9.99 USD at 480p (6 credits) or 12.99 USD at 720p (14 credits). Signed-in accounts can buy one-time packs of 27.99 USD for 30 credits, 71.99 USD for 100 or 129.99 USD for 200. There's no subscription. Every clip is 15 seconds, vertical, with a newly generated voice, made from one photo of an adult or a pet (FAQ).

---

v4 (2026-11-05): NLI claim pairs

What changed in v4 (2026-11-05): a new file and two scripts. data/nli-pairs-2026-11-05.jsonl has 31 premise/hypothesis pairs about the studio at hittheroaddude.app, labelled entailment, neutral or contradiction. validate_pairs.py re-fetches every quoted page and confirms each quote is still there. baseline_nli.py is a four-rule baseline, so a model has something to beat. The v3 routing set, v2 decision cases and v1 Q&A snapshot are unchanged and still load as their own configs.

The question behind it: when an assistant answers "how much is it?" or "is it free?" from several pages of the same site, do those pages agree? And can a model tell a paraphrase from a contradiction when both use the same words? Every premise in this file is copied verbatim from a live page. 12 hypotheses are also verbatim page quotes (page-vs-page pairs), and 19 are claims I wrote to sound like typical wrong or unanswerable assistant statements (constructed pairs).

What this is not: there are no images, videos, faces, voices, generated outputs or user data. The person in the original viral video is a private individual, and nothing here names him.

Who wrote it: the builder of hittheroaddude.app. The labels reflect my reading of my own site. Treat them as first-party.

Files (v4)

data/nli-pairs-2026-11-05.jsonl, one pair per line:

Field	Meaning
id	hitt-nli-001 … hitt-nli-031
topic	e.g. price, packs, refund, catalog, format, free, consent, sharing, dates
premise, premise_url	A sentence or fragment copied verbatim from the page at premise_url on 2026-11-05
hypothesis	The claim to judge
hypothesis_source	page (verbatim from hypothesis_url) or constructed (written by me; hypothesis_url is null)
label	entailment (9), neutral (5), contradiction (17)
rationale	One line on why the label holds
checked	Date the quotes were confirmed live

Three example lines (the last two abridged with ...):

{"id": "hitt-nli-003", "topic": "packs", "premise": "Credit packs are one-time purchases without automatic renewal.", "premise_url": "https://hittheroaddude.app/llms.txt", "hypothesis": "Packs do not renew.", "hypothesis_source": "page", "hypothesis_url": "https://hittheroaddude.app/pricing.md", "label": "entailment", "rationale": "Paraphrase.", "checked": "2026-11-05"}
{"id": "hitt-nli-022", "topic": "refund", "premise": "A delivered clip is not refunded as a change of mind.", "premise_url": "https://hittheroaddude.app/refunds.md", "hypothesis": "You can get a refund on a delivered clip if you don't like it.", "hypothesis_source": "constructed", "hypothesis_url": null, "label": "contradiction", ...}
{"id": "hitt-nli-030", "topic": "credits", "premise": "Credits never expire", "premise_url": "https://hittheroaddude.app/pricing/", "hypothesis": "Credits can be moved to another account.", "hypothesis_source": "constructed", "hypothesis_url": null, "label": "neutral", ...}

The page-vs-page contradictions are real (v4)

Four of the 12 page-vs-page pairs are labelled contradiction, and they are genuine inconsistencies on the live sites today, not constructed examples:

• Shared catalog prices are stale. The pricing page's cross-site catalog lists "Tiny Desk Outstanding 480p $9.99 · 6 credits", while tinydeskoutstanding.video's own pricing twin says "480p is 9.98 USD (998 credits)." The Bama Bound and Malfoid rows also disagree with those sites' own pricing pages (pairs 007 to 009).
• Two "updated" dates. The privacy page says "Last updated 2026-10-26" while its .md twin says "Updated: 2026-10-30" (pair 006).
• One near-miss: llms.txt vs FAQ. llms.txt says "Prices and required credits vary by model and settings", while the FAQ says "You do not pick a model or write a prompt." I labelled this neutral rather than contradiction (pair 005): both can be true if "settings" means the resolution choice, but an assistant reading only llms.txt would get the wrong idea.

This studio's own prices agree everywhere I checked: 9.99 USD (6 credits) at 480p, 12.99 USD (14 credits) at 720p, one-time packs of 27.99 USD for 30 credits, 71.99 USD for 100 and 129.99 USD for 200, and "Credits never expire" (pricing).

Validation (v4)

$ python3 validate_pairs.py data/nli-pairs-2026-11-05.jsonl
31 pairs, 0 quotes missing, 0 checks skipped (page unreachable)

The validator fetches each URL once with the standard library, strips tags from HTML pages, collapses whitespace, straightens curly quotes, and checks each quote as a substring. It retries a page up to three times. During this run two pages timed out on the first try and loaded on the second. It exits 1 if any quote is missing, 2 if a page stays unreachable, and 0 otherwise. Re-run it before relying on a record. A missing quote means the page changed, and the label may no longer hold.

Baseline (v4)

baseline_nli.py applies four rules in order: different number sets → contradiction, negation on exactly one side → contradiction, word overlap (Jaccard ≥ 0.25) → entailment, otherwise neutral.

$ python3 baseline_nli.py data/nli-pairs-2026-11-05.jsonl
accuracy 0.742 on 31 pairs (majority class 'contradiction' = 0.548)
gold \ pred       entailm  neutral  contrad
entailment              4        4        1
neutral                 0        3        2
contradiction           0        1       16

The misses are the instructive part:

• Arithmetic looks like disagreement. Pair 002 ("30, 100 or 200 credits, about 5, 16 or 33 … runs") has numbers the premise doesn't contain, so rule 1 calls it a contradiction. It's entailed by dividing by 6.
• Negation in both forms. "There are no free clips or free credits" vs "Every clip is paid. New accounts start at zero credits." Both sides are negative ("no", "zero"), so rule 2 doesn't fire, and the word overlap is too low for entailment.
• Constructed contradictions without a negation word. "You can get a refund on a delivered clip if you don't like it" is predicted neutral.
• Neutral claims that sound like denials. "Credits can be moved to another account" vs "Credits never expire" is predicted contradiction purely because of "never".

The 16/17 on contradictions mostly comes from rules 1 and 2. With 31 pairs, every result here is anecdotal. The point is a fixed, re-checkable test set, not a leaderboard.

Uses (v4)

• Site consistency checks. Run an NLI model over page-vs-page pairs after every content change. A new contradiction is a page to fix.
• Assistant answer checking. The constructed hypotheses are typical wrong answers (free clip, 1080p, 30-second version, refund on change of mind, app download). A grounded assistant should reject them against the premise.
• A template for building the same kind of file for any small site: quote, claim, label, rationale, date, validator.

Loading with no dependencies:

import json
pairs = [json.loads(l) for l in open("data/nli-pairs-2026-11-05.jsonl", encoding="utf-8")]
print(len(pairs), sum(p["label"] == "contradiction" for p in pairs))

With 🤗 datasets: load_dataset("conan123/hittheroaddude-guides", "nli_pairs"), and likewise "query_routing", "pages", "decision_cases" and "qa_2026_11_02".

Out of scope

• Identifying the person in the original video. Not supported. Please don't use these records to try.
• Judging clip quality or ranking AI generators. Nothing here measures a render.
• Disambiguating anything beyond the five entities in entities-2026-11-09.jsonl. Other works share these words too.
• Other sites' prices as facts. The catalog pairs record what each page said on 2026-11-05. Check the live pages.

Changes and known stale records

• 2026-11-09 (v5): added data/mentions-2026-11-09.jsonl (36), data/entities-2026-11-09.jsonl (5), link_baseline.py and validate_mentions.py. mentions is now the default config.
• Stale since 2026-11-09 in v4: pair hitt-nli-007's hypothesis quote ("480p is 9.98 USD (998 credits).") no longer appears on tinydeskoutstanding.video/pricing.md, which now reads "Each video is $9.98 at 480p". The contradiction it records still holds: the Hit the Road Dude catalog row still lists Tiny Desk Outstanding at "$9.99 · 6 credits". The other 30 pairs validated on 2026-11-09.
• 2026-11-05 (v4): added data/nli-pairs-2026-11-05.jsonl (31), validate_pairs.py and baseline_nli.py. nli_pairs is now the default config.
• 2026-11-04 (v3): added data/queries-2026-11-04.jsonl (40), data/pages-2026-11-04.jsonl (28) and route_bm25.py.
• 2026-11-03 (v2): added data/eval-cases-2026-11-03.jsonl (22 decision cases) and validate_cases.py. Moved the 2026-11-02 records unchanged to data/qa-2026-11-02.jsonl.
• Stale in the 2026-11-02 file: record out-model names "Seedance 2.0". The FAQ's visible text no longer names a model, though some pages' structured data still does. It's kept as a dated snapshot.
• Expected to go stale: the catalog pairs (007 to 009) and the date pair (006) record inconsistencies. When the pages are fixed, those quotes will stop validating, which is the intended signal.

Citation

@misc{hittheroaddude_guides_2026,
  title  = {Hit the Road Dude guides: entity-linking mentions, NLI claim pairs, query routing, decision cases and Q\&A snapshot},
  author = {Li, Peiguan},
  year   = {2026},
  note   = {v5, mentions checked 2026-11-09},
  url    = {https://hittheroaddude.app/}
}