Back to the catalog

The making of a living catalog

Building Monitor Supply

We wanted the simple, standardized spec table of a phone database, but for every monitor. Then we asked Codex to help build the site, investigate the manufacturers, and turn the whole thing into a system that can keep checking its own work.

Catalog snapshot1,164 monitorsfrom 12 brandsSee catalog health
Official sourcesCatalogs, PDPs, specs, PDFs
Brand pipelinesRepeatable code, not copy-paste
Evidence gatesUnknown is allowed; guessing is not
One catalogThe same fields across every brand

Monitor specs are messy.

Phone buyers can open a site like GSMArena and compare two devices row by row. Monitor buyers get a different experience. One brand says "Nano IPS Black." Another says "Fast IPS." A third puts the useful numbers in a PDF. Product names are long, refresh rates may change with resolution, and yesterday's monitor quietly vanishes from the current catalog.

Monitor Supply is our attempt to make that mess boring in the best possible way: one durable catalog, one normalized schema, and enough source transparency that a buyer can see where a fact came from. It complements lab reviewers such as RTINGS. They can measure a smaller number of displays deeply; we can map the market broadly and give every model the same basic language.

1shared schema
3coverage tiers
0guesses required

Code, Codex, or a person?

Each job goes to the simplest tool that can do it safely. Repeated work belongs to code. Unclear evidence can go to Codex. A person handles the few decisions where the sources still do not agree.

Deterministic codeCodex reviewHuman review
DoesFetch catalogs, read known fields, compare changes, and run checks.ExampleSamsung's API returns a model code and URL. Code adds or updates that exact record.ProducesA repeatable result.DoesInvestigate a new label, hidden page, or unclear piece of official evidence.ExampleAn HDR field contains a certification plus a paragraph of legal text. Codex proposes the clean label with evidence.ProducesA source-linked proposal, not a live edit.DoesResolve source conflicts and decide what is safe to publish.ExampleThe product page says 60 Hz while an official PDF says 75 Hz. A person reviews the conflict.ProducesA final decision or an honest unknown.

How two brands get imported.

A brand catalog tells us which products exist. A product page tells us what each one can do. Sometimes a PDF has the details the page forgot. The pipeline joins those sources into one record and keeps a link to the evidence.

LG

LG: API, then product page

The catalog finds every model. The product page fills its spec sheet.

Get every productLG's Coveo API returns IDs, URLs, and images
Read its product pageStructured page data contains the display specs
Fill core fields (P0)27 in / 3840 x 2160 / IPS / 60 Hz
Check and publishMissing critical facts stop the new record
What comes outLG 27-inch | 3840 x 2160 | IPS | 60 Hz | USB-C

The raw LG labels are now in the same columns used for Dell, Samsung, HP, and every other brand.

HP

HP: page first, PDF when needed

The normal spec table does most of the work. QuickSpecs fills supported gaps.

Get every monitorHawk Search separates monitors from bundles
Read core fields (P0)The product page supplies identity and display facts
Add detail (P1/P2)QuickSpecs can add ports, brightness, and dimensions
Keep gaps visibleNo official value means unknown, not a guess
Real fallbackHP Series 7 Pro 738pu QuickSpecs

Its PDF supplied IPS Black, 3840 x 1600, 60 Hz, 400 nits, 2000:1 contrast, and Thunderbolt 4.

The source changes by brand.

We prefer the most structured official source available. When a neat API does not exist, the pipeline steps down carefully instead of pretending every site is the same.

Official APIBest for complete discovery, stable IDs, stock, and prices.
Page dataJSON-LD, Next.js payloads, and labelled server-rendered specs.
Real browserChrome or Playwright for clicks, client rendering, and protected pages.
Page JavaScriptSmall in-page scripts can read data already rendered for the shopper.
Official PDFManuals and timing tables can resolve facts a PDP leaves out.
Review queueIf the evidence still does not support a claim, the field stays unknown.
APIHTMLChromePDF
Official-source evidence

AOC is a good example of the PDF escape hatch: its product page omitted one refresh rate, but the official manual's timing table documented 1920 x 1080 at 60 Hz. The fallback is narrow, cited, and saved. It is not a license to infer the rest.

What we need before publishing.

We grouped the schema by consequence, not by how impressive a field sounds. P0 is the minimum needed to identify and compare a monitor without misleading anyone. P1 covers the questions buyers ask most often. P2 makes deeper side-by-side comparison possible.

P0
Core facts

Brand and model / Official product URL / Product image / Screen size / Native resolution / Panel type / Native refresh rate / Aspect ratio / Smart or conventional

Example: a 27-inch 4K IPS monitor at 60 Hz, with an official URL and image.
P1
Buying facts

Price and model number / Brightness and contrast / HDR / Ports and USB-C display / Curved, portable, or foldable / Stand adjustment and speakers

Example: 400 nits, DisplayHDR 400, HDMI, and USB-C with 90 W charging.
P2
Deep details

Color depth and gamut / Response time and VRR / KVM and PiP/PbP / VESA, dimensions, and weight / Typical power use

Example: 98% DCI-P3, 1 ms response, KVM, and a 100 x 100 mm VESA mount.

Release year sits outside these coverage scores. Brands often omit it, so it is best effort: an official announcement is ideal, and a focused web search can locate one. Missing release year alone never holds a monitor back.

Turning marketing into data.

Manufacturer pages are written to sell one product. A comparison catalog has to make many products speak the same language without flattening meaningful differences.

"VESA DisplayHDR 400 AdaptiveSync 180Hz ...""HDR10 compatible""True Black 400""4K 240Hz / FHD 480Hz"
Evidence-aware normalizerKnown labels only
HDR DisplayHDR 400HDR HDR10HDR True Black 400Native 4K at 240 Hz

We trim boilerplate, preserve named certifications, and do not upgrade vague compatibility into a stronger standard. For multi-mode displays, the card uses the refresh rate at native resolution and the full verified mode table remains on the product page.

Only fetch what changed.

Every pipeline is designed to be incremental and idempotent. It stores stable product identity, source hashes, first-seen and last-seen times, and the last verification date. An incremental run fetches detail only for products that are new, changed, stale, or already waiting for review.

DiscoverRead the complete official lineup
Hash and diffFind new, changed, stale, missing
Fetch selectivelySkip work that has not changed
ValidateCoverage, evidence, and source health
PublishRegenerate the static public artifact
Yesterday119 product IDsSaved with a source hash
Today2 new, 3 changed114 unchanged products are skipped

Disappearance is handled just as carefully. A monitor is marked deprecated only after a complete, authoritative, healthy catalog run omits it. Failed requests and suspicious count drops cannot erase products or change lifecycle state. We keep old pages because discontinued monitors do not stop existing the day a brand removes a listing.

The repo is the memory.

Each successful investigation leaves an operating manual behind. Pull the repository onto another Mac, and the next agent can see how a brand is discovered, what can go wrong, what the last healthy run found, and how to run it again.

monitor-supply/
research/ What we learned about each brand
sources/ Strategy, schedule, health, and AI policy
state/ Identity, hashes, coverage, and last-seen history
runs/ and review/ Audit trail and unresolved evidence
scripts/ Deterministic brand runners
.codex/skills/ The reusable onboarding playbook
generated/ Static data read by the public site

SQLite is useful locally for investigation, but it is not required in production and it is not the portable source of truth. The live site reads generated catalog data and serves filtered results page by page.

A Mac mini runs the checks.

The operating model is simple: Codex scheduled tasks on a Mac mini invoke each brand's deterministic incremental command. Normal runs finish without AI judgment. When a run produces a small evidence queue, Codex can investigate those specific items and submit structured proposals. Humans see the exceptions, not hundreds of unchanged products.

Codex taskWake on the brand schedule
Brand runnerExecute the saved source strategy
Run summaryNew, changed, unchanged, held
Catalog updatePublish a reviewed, auditable diff
Example run summarySamsung check complete
Discovered
119
New
2
Changed
3
Unchanged
114
Illustrative numbers, not a claim about the latest live run.

Research once. Reuse it forever.

Before

One long manual expedition

  • Find every catalog and product page by hand
  • Reverse engineer each site from scratch
  • Copy specs into a one-off spreadsheet
  • Normalize labels manually, row by row
  • Repeat the entire exercise when the lineup changes
With Codex

Research once, encode the result

  • Investigate APIs, page data, browser paths, and PDFs
  • Turn the finding into a deterministic runner
  • Save source rules and health checks beside the code
  • Review only evidence that the parser cannot settle
  • Rerun incrementally on any machine

The breakthrough is not that AI can read a product page. It is that an afternoon of exploration can become infrastructure, documentation, tests, and a process that keeps paying rent after the chat is over.

Use AI for the hard parts.

This build crossed several Codex model generations. The development record includes GPT-5.5 and later variants internally labelled Terra and Sol. The newer reasoning-heavy sessions did much of the modern pipeline work: endpoint research, parser design, source recovery, and the argument about exactly what "smart monitor" should mean.

Reasoning tokensResearch, architecture, edge cases, and review
Committed codeParsers, gates, state, tests, and documentation
Cheap rerunsMost future checks are deterministic

We are deliberately not printing a made-up percentage chart from memory. Exact model shares and token totals should come from exported Codex usage telemetry. The durable lesson is clearer anyway: the expensive reasoning is concentrated in discovering a source and handling exceptions; unchanged daily checks should not require a fresh grand investigation.

What still needs work.

01

Turn plans into observed schedules

Install and monitor brand tasks, then expose their actual run history publicly.

02

Raise deep-spec coverage

Some brands simply publish less. Better official fallbacks can improve P1 and P2 without inventing data.

03

Make change review excellent

Small, evidence-rich diffs should be easy for a person to approve, reject, or correct.

04

Measure our own accuracy

Sample published records, compare them with official sources, and track precision over time.

Every monitor. One spec sheet.

That is the promise. Codex helps us explore the messy web, deterministic software keeps the promise repeatable, and humans remain exactly where judgment matters.