Why the build checks the words.
ADJL Technology is new. We don’t have published clients, metrics or awards to point to yet. A site that hints otherwise gets found out in the first conversation, and after that nobody believes the rest of it.
Good intentions don’t survive every small edit. Someone adds a line to a page that felt thin. A number from a draft makes it into the final copy. So the rules are written as code, and the code runs on every deploy (each time the site is published). If a check fails, the new version doesn’t ship, and the last good one stays live.
Hype and invented numbers stop the build.
The first check, check-claims, holds a list of phrases that sell without saying anything. Claims to be the best or the newest. Stock lines about experience. Trust borrowed from people we can’t name. If one turns up anywhere on the site, the build stops and prints the words around it.
It also looks for numbers doing a job they haven’t earned. A percentage next to a word like faster or cheaper. A sum next to saved. A count of clients, customers or projects, in digits or spelled out in words. We have no measured results to report yet, so any sentence like that would be invented.
It reads more than the visible page. It reads the labels a screen reader speaks, image descriptions, the structured data search engines quote, and the files written for AI tools. A claim isn’t acceptable because it sits where a person rarely looks.
And it fails if the site ever loads an analytics script (code that tracks what visitors do on a site). The privacy page says there are none, so the policy has to change first.
A check on how the copy sounds.
The first version of this site read as machine-written. Counting showed why. It leaned on dashes, on sentences that turned on a reversal, and on long polished lines with nothing short between them. Each sentence was fine on its own. Together they sounded like a template.
So check-voice measures how often things happen, not which words appear. For every thousand words of copy, it counts:
- Dashes used as asides.
- Sentences built on a reversal.
- Colons that set up a punchline.
- Phrases spelled out in full where a person would contract them.
- A short list of soft marketing words.
It also checks that sentences stay short on average and that a fair share are very short. Over any limit, the build fails.
Hiding words doesn’t get around it. Interface labels are skipped, since they aren’t sentences. But if the skipped text grows past a set share of the site, the check fails anyway.
Real numbers carry a label.
Some numbers on this site are real. Page sizes are measured when the site is built. Load times are measured in your browser while you read. Those are allowed, as long as they say what they are.
A third check, check-provenance, makes every figure and demo carry a small label that reads Live, Build, Recorded or Illustration. Live means measured in your browser just now. So no page may ship with a Live label already in its HTML, and only the script that did the measuring can set one. Anything left out on purpose is drawn hatched and labeled, so a withheld value never looks like a missing one.
What it costs.
Writing under these checks is slower. A true sentence sometimes has to be rewritten because it looks like a false one. A count of something we really did would still fail. When something becomes true, the fix is to change the check on purpose and write down why in the commit (a saved, dated change in the code’s history).
The checks read their own descriptions too. This note can’t quote the phrases it describes, because the build would stop on them. The page about how this site is built paraphrases each check for the same reason.
And the checks miss things. A list of phrases can’t tell a careful claim from a careless one, and a limit on dashes can’t make dull writing good. A person reviews anything that’s expensive to get wrong. The checks catch what a machine can, on every deploy.
See it run.
Every check runs on every deploy. The build guards section lists each one and what it stops, and shows the output of the run that built the page you’re on. The code is public too, in the site’s repository on GitHub.