DEV Community: Adrian M. Peticila

The Cadence Gate: make the model prove it wrote like a human

Adrian M. Peticila — Thu, 05 Nov 2026 12:47:52 +0000

Every style prompt ends the same way. "Write naturally. Vary sentence length. Avoid corporate language." The model agrees, writes 600 words, and ships the same flat rhythm as the last run.

The prompt is a request. Nobody checks the answer.

A gate is different. It reads the file after the model writes it, computes a number, and fails the check when the number misses the floor. The model can still write badly. It cannot do it silently.

One file, no network

grai-gate is a single Python file with no dependencies outside the standard library. It imports re, sys, json and math. It never opens a socket, never reads an API key, never writes a cache file.

It runs in three places:

A command line: pipx run grai-gate README.md
A pre-commit hook, before the commit lands.
A GitHub Action, on the pull request.

The analyzer is the same in all three. Only the wrapper changes.

What it measures

The core metric is sentence-length burstiness:

CV = standard deviation of words per sentence / mean words per sentence

A draft that alternates a 6-word line with a 30-word explanation gets a high CV. A draft where every sentence runs 14 to 18 words gets a low one.

The thresholds come from a 134,522-post study:

Band	CV	Meaning
Flat	under 0.32	Hard flag, the draft fails
Warning	0.32 to 0.35	Hard flag
Borderline	0.35 to 0.40	Soft flag, three points
Human	0.40 and above	No cadence flag

The gate needs at least four sentences and a mean length of four words before it computes a CV. A three-line stub has no measurable rhythm, so the gate stays quiet instead of inventing one.

The structural checks

Vocabulary lists age fast. Structure changes slowly, so the gate checks structure.

Check	What it catches
Flat cadence	CV under 0.32
Dash punctuation	Em dashes, en dashes, double hyphens used as punctuation
Opening formula	"Here is why" at the start of a sentence
Contrastive negation	"Not X, but Y" used as a fake distinction
Arrow cascade	`->`, `=>`, arrows used as bullets
Triadic padding	Three bullets with near-identical sentence lengths
Weak closer	"Thoughts?" and similar
Dead lexicon	A short list of words that signal template prose

The dead lexicon is deliberately small. A long list produces false positives on technical writing, and a false positive teaches the team to skip the gate.

How the score works

The score starts at 100. Each flag subtracts a fixed penalty. A hard flag caps the result below the pass mark even when the arithmetic would pass.

score = max(0, 100 - sum(penalties))
pass = score >= 85 and hard_flags == 0

The pass condition has two parts for a reason. A draft can collect several soft flags, score 86, and still fail because one hard flag fired. The team sees one number in CI and one honest verdict underneath.

What the analyzer ignores

False positives kill adoption, so the parser strips the parts that are not prose:

Fenced code blocks and inline code.
YAML frontmatter at the top of the file.
Link URLs. Link text survives.
Images.
Table separator rows.
Headings for the cadence math. Headings still get scanned for tells.

A README full of commands should not fail because the commands look like short sentences.

The report card

A failing file prints one compact card:

[grai-gate] Slop Score: 64/100 (CV: 0.27 | Flags: 2)
- Worst offender: flat cadence ("CV 0.27 across 12 sentences")
- Tells detected: flat cadence, zombie words (x2)
- Fix prompt: "Rewrite to increase sentence burstiness (target CV > 0.45) and eliminate flat cadence, zombie words."
- Pro Cockpit: Full Voice DNA & repair workbench at https://grai.page?utm_source=devto&utm_medium=article&utm_campaign=gate_v0.1#developer

A clean file prints nothing by default. That matters. A gate that prints on every run becomes noise, and noise gets muted.

Install it in a repo

One command:

pipx run grai-gate README.md

Pre-commit:

repos:
  - repo: https://github.com/adrianpeticila/grai-gate-action
    rev: v0.1.5
    hooks:
      - id: grai-gate

GitHub Actions:

- uses: adrianpeticila/grai-gate-action@v0.1.5
  with:
    fail-on-slop: "false"

The Action is advisory by default. It scores only files changed in the pull request, and it writes the card to the workflow summary, so the reviewer sees it on the checks page without opening the job log. Set fail-on-slop: "true" when the team wants a hard gate.

The command line exits 0 on clean, 1 on slop, and 2 on an input error. That contract lets any CI system consume it without parsing text.

Why CI and not a writing app

A writing app catches the draft the writer remembers to paste. CI catches every markdown file the team ships, and it catches the ones an agent wrote at 2am when nobody was watching.

The gate also runs before the commit, which is the last moment the writer still has context. A failure there costs one edit. A failure in review costs a round trip.

Limits

The gate judges cadence, not truth. It cannot tell whether a claim is correct, a quote is real, or a number is sourced.

It also cannot hear intent. A manifesto written in short declaratives may score low and still be right for the piece. The gate reports, and a person decides.

And it only sees files. A pull request description typed in a browser never reaches disk, so the gate never scores it.

It is a style gate, not an authorship detector. On the v2 corpus, it flagged 7 of 63 model docs and 3 of 58 human docs.

The point

A prompt asks a model to behave. A gate measures whether it did. The second one survives a model upgrade, a new teammate, and a deadline.

The engine is MIT and one file. Run it on your worst README and see whether the number matches your read.

pipx run grai-gate README.md

Repo: https://github.com/adrianpeticila/grai-gate-action

If you want the full calibration workbench behind the gate, it lives at https://grai.page?utm_source=devto&utm_medium=article&utm_campaign=gate_v0.1#developer

We audited 134,522 posts to see why AI writing still sounds fake (and open-sourced a deterministic syntactic gate)

Adrian M. Peticila — Fri, 23 Oct 2026 09:30:30 +0000

in 2025/2026, everyone removed the obviously AI keywords from their prompts. but even non-dev/tech-minded readers can detect an LLM post in the first 3 sentences.

why? because they removed the words that people made fun of, but not the syntactic patterns that betray RLHF models.

to quantify the change, we audited 134,522 random organic linkedin posts on 1,499 founder profiles, over jan'23 to sep'26 timeframe (LigoSocial dataset).

empirical change: words got nuked, structure went wild

SYNTACTIC PATTERN	JAN'23	SEP'26	RELATIVE CHANGE
mocked ai verbs	4.2%	0.5%	-88.1%
"here's why" epiphany onset	1.3%	9.6%	+7.4x
"it's not X, it's Y" negate	1.2%	5.9%	+4.9x
arrow & emoji bullets waterfall	0.6%	12.3%	+20.5x
avg. sent burstiness (CV=$\sigma$/$\mu$)	0.48	0.23	-52.1%

most indicative is burstiness (CV=$\sigma$/$\mu$ - std.dev. of sentence word count over avg. sentence word count)

normal human, non-assisted text: CV=0.48. you may see sharp jumps of 4-word observation. and then next to it, 32-word breakdown of architecture. default GPT4o/claude 3.5 sonnet. tightly cluster around 14-18 words/sentence. (CV=0.21-0.23).

why negative prompts are not effective

if you ask llm "vary sentence length. don't use contrastive negatives". the model takes it as a soft weighting in attention. but then, in 3rd paragraph it tries to converge back to a safe, well-mannered 15-word mean (rlhf).

you can't use a prob. generator as deterministic linter.

generation vs. validation (grai)

we designed grai to be two layers:

OpenCore MIT Instruction Harness + Agent Skill: github.com/adrianpeticila/grai
622kb air-gapped html5 workbench: grai.page

The model will not self-censor: deterministic external (non-LLM) vanilla JS preflight engine is applied to each draft:

CONTRASTIVE_NEGATION. Flags "It's not X. It's Y" / "Less X, more Y".
LESS_MORE_SYMMETRY. Corporate paralleslisms "Stop X. Start Y".
EPIPHANY_OPENER. Flags "Here is why" "The harsh truth is", "Let that sink in".
ARROW_BULLET_SLOP. Flags cascading Unicode/emoji arrows/bullets (→ ↳ 🚀💡).
TRIADIC_PADDING. Flags catchy triadic slogans. "No X, No Y, Just Z".
LEXICAL_SLOP. Flags remaining synth vocab red flags.
HARD_BURSTINESS_FLOOR ($CV > 0.32). Computes sentence wordcount variance. (Preserves decimal "3.14", abbreviations "U.S.", "Dr." etc.) Any draft that does not have $CV > 0.32, is rejected.
Engineering quirk. FIPS 180-4 SHA256 on "file://"

We made the workbench (grai.html) to be 100% offline from disk. Use the file:// protocol and strict Content-Security-Policy (connect-src 'none' by default).

Here's where we ran into some problems testing on WebKit/Chromium. They block window.crypto.subtle.digest("SHA-256") on file:// (local files are not Secure Context). We need SHA256 fingerprint of author's voice profile to be deterministic for our printable A4 Voice DNA Dossier. So we created a pure JS FIPS 180-4 SHA256 workaround. To have the same hash whether we load it from disk or over HTTPS.

Try the Scorer, or the MIT Harness

• Live Cadence Gate Scorer (free - no signup required) https://grai.page/#test

• Full 134522-post Methodology Report https://grai.page/methodology

• Github repo (MIT skill & instructions) https://github.com/adrianpeticila/grai

Ninety-Two Blog Posts, Five Percent of the Answer

Adrian M. Peticila — Tue, 29 Sep 2026 21:17:59 +0000

Every quarter I get asked the same question by a marketing director: why is our blog traffic up and our AI visibility flat? The answer is arithmetic, and it is not flattering.

Last quarter I reviewed the content budget of a company that had shipped ninety-two blog posts in a year. Ninety-two. Every one researched, written, edited, SEO-checked, and promoted. The company was delighted with the traffic. It was also invisible in every AI answer about its own category.

That gap is the entire argument of this piece, and it is not a fringe position. In June 2026, llemmy pulled 37,547 citations out of 5,200 AI answers generated by ChatGPT, Claude, Gemini, Perplexity and Google AI Overviews. About 5% of those citations pointed at the brand's own website. Nineteen out of twenty went somewhere else.

Ninety-two posts competed for that 5%.

Worse, most of those posts never got even that. Semrush, working with Kevin Indig, analysed thousands of domain appearances across AI search engines and found 62% of AI citations are what they call ghost citations. The model links your site as a source and never says your name. You collect the authority, the traffic does not arrive, and the brand does not register in the answer. The engines also behave in opposite ways. Gemini names a brand in 83.7% of answers but cites it as a source only 21.4% of the time. ChatGPT reverses it: 87% citation rate, 20.7% mention rate.

Being right is not the objective. Being named is.

So what is happening inside these systems? Search ranked pages. AI retrieval ranks sources, and it rewards something pages were never built to carry: agreement between independent nodes. When several unrelated sources describe you the same way, the odds a model repeats that description rise sharply. When your own blog makes a claim and nothing else in the world corroborates it, you have a weak signal in a large amount of noise. The model is not weighing the quality of your argument. It is counting how many places that have nothing to do with you say the same thing.

The 5W Citation Source Audit makes the consequence concrete. Only about 12% of AI citations overlap Google's top 10 results. Wikipedia at 13.15% and Reddit at 11.97% together account for more than a quarter of US ChatGPT citations. YouTube appears in 23% of Google AI Overview answers.

Reddit, Wikipedia, YouTube. None of them are trade publications, and none of them will accept a media kit. The expensive, relationship-driven work this industry has relied on for twenty years was built to earn links in the marketing press. That work still matters. It is simply no longer the mechanism doing the heavy lifting.

The budgeting consequence is uncomfortable for anyone whose career runs on owned content. The blog is not your message to the market. It is your record for the machines. Structured data, entity markup, canonical facts, crawler policy: that is what the owned domain is for. It is the evidence locker, not the pulpit. Being believed happens on somebody else's domain.

Three moves follow, in the order I would fund them.

Cut first, measure second. Audit what the models currently say about you, not what you say about you. Run the prompts your buyers actually type, read the footnotes, and find out whether you are named, cited, or ignored. Most teams have never done this, and most discover the answer is "ignored".

Then redirect the savings. The citations cluster in review sites, directories, communities and structured records, not in owned properties. Move the ninety-two posts of budget into places a machine is willing to read about you by people who do not work for you.

And fix the plumbing underneath. Get the company and leadership names into structured, machine-readable, third-party records, because entity resolution decides whether a model merges your CEO with somebody who has the same surname and a louder footprint.

None of this is a content strategy. The brands that win the AI answer will be the ones that appear, accurately and often, everywhere the engines look. Your own website was never going to be that place. It is roughly 5% of it, and 5% is not a budget line.

By Adrian M. Peticila, CMO & AI Practitioner

Website: peticila.ro

Why I Built Gorgona: Turning Runaway AI Agents to Stone

Adrian M. Peticila — Wed, 02 Sep 2026 20:37:03 +0000

Running multiple digital brands simultaneously with autonomous AI agents sounds like a dream until you wake up to a $500 token bill, an agent stuck in an infinite tool call loop, or sensitive credentials leaked into public commits.

When you manage several brands alone, you cannot afford probabilistic safety. You need cold, deterministic discipline.

That is why I created Gorgona.

The Problem With Modern Autonomous Agents

Most agent frameworks operate on optimistic recursion. The agent plans, calls tools, observes outputs, and continues thinking. When an unexpected error occurs, the typical failure mode is disastrous:

The Infinite Hallucination Loop: The agent attempts to fix a missing dependency, fails, repeats the same terminal command 15 times, and exhausts rate limits.
Context Bleed: An agent working on Brand A accesses notes or credentials meant for Brand B, embedding them into commits or deploy scripts.
The AI Slop Creep: Text generated by runaway prompts becomes saturated with buzzwords ("delve into", "tapestry of", "fostering innovation") and unneeded punctuation.

You do not solve deterministic engineering problems with probabilistic prompts like "Please be careful not to leak secrets".

You solve them with guardrails that turn runaway agents to stone.

What Is Gorgona?

Gorgona is a lightweight, zero-dependency Python engine designed to enforce uncompromising boundaries on AI agents.

       Autonomous Agent Step
                 │
                 ▼
         [ Gorgona Engine ]
                 │
  ┌──────────────┼──────────────┐
  ▼              ▼              ▼
Exposure     Isolation      Text Clean
 Guard         Guard          Guard
  │              │              │
  └──────────────┼──────────────┘
                 │
         [ Memory Graph ]
                 │
                 ▼
       Verified or Frozen

If an agent violates a rule, Gorgona halts execution immediately. No polite warnings. No retries. The agent is frozen before disk writes or git commits can occur.

Four Pillars of Stone

1. Exposure Guard

Detects leaked credentials, Bearer tokens, private SSH keys, and sensitive environment files before any push or deploy action.

2. Isolation Guard

Enforces strict brand borders. If code or documentation for one client references identifiers from another client, execution stops immediately.

3. Text Cleaner Guard

Enforces strict prose discipline. It flags AI markers and eliminates characters that scream synthetic generation, including a strict zero em-dash policy.

4. Memory Graph Guard

Monitors agent recursion using depth-first search cycle detection. If an agent loops over the same action sequence, it triggers an immediate breaker.

Zero Dependencies Philosophy

Gorgona was built with standard Python libraries. No heavy dependencies. No network calls. No telemetry. It runs in milliseconds inside lightweight CI/CD containers, local CLI environments, or edge workers.

gorgona doctor
gorgona scan ./output-directory

The Future of Solo Engineering

Operating as a solo builder at scale requires ruthless automation paired with ruthless constraints. Autonomous agents are incredible force multipliers, but only if they are held accountable to deterministic standards.

Gorgona is available open source on GitHub:
👉 https://github.com/adrianpeticila/gorgona

Turn runaway agents to stone. Build with discipline.