The Content Engine

What the content engine is

The content engine is the writing brain of the system. Once a night it turns the raw facts of a website network — the sites in it, the marketing principles behind them, and how their AI-readiness scores are moving — into short, publishable social posts. Those posts flow into a queue, and from there either go out automatically or wait for a human to approve them.

It is deliberately unglamorous. There is no large language model composing prose at post time. Instead there is a small library of proven sentence patterns, a clean feed of verified facts, and a set of rules deciding which pattern gets which fact tonight. The result reads like a person wrote it, but every claim in it traces back to a real row of data.

Think of it as the difference between a reporter and a novelist. A novelist can write forever from imagination. A reporter writes only what the sources support — and when a source is thin, the reporter holds the story rather than making something up. This engine is a reporter.

The four content families

For the owner's own network (the tenant named wholetech), everything the engine writes falls into one of four families. Each feed item carries a kind, and a template applies only to items of its kind — and only when every field that template needs is present. Here is the whole cast at a glance:

site_feature — the network tour

This is the workhorse. With 177 sites on hand, the engine has a deep, honest well of things to say: each item is simply a real domain and its real one-line description, straight from the sites file. The template introduces the site and what it does, then links to it. Because the description is written once, by hand, and reused verbatim, there is nothing to hallucinate.

ai_tip — teach, don't sell

Not every post should be about you. The ai_tip family shares one real marketing principle at a time, drawn from a library of 47 skills. The feed builder prefers each skill's own stated goal; if that isn't clean, it falls back to a genuine principle heading from the skill. What it never does is invent a “tip” out of thin air — the words come from the library, not from a model's imagination.

milestone — proof the work works

This is the family clients care about most, because it is a receipt. The engine compares this week's Agents-First scores against last week's and looks for real movement. It only celebrates a gain when it clears a meaningful bar: the improvement is at least 5 points and the site has landed at 60 or above. Small noise and low scores don't get a victory lap.

spotlight / new_site — the welcome

When a site appears in the scorer for the first time — an entry that simply wasn't in last week's snapshot — the engine marks the occasion. It's a lighter cousin of the milestone: the fact is “this is new,” sourced the same honest way, by diffing the score snapshots.

The honesty guard

This is the heart of the whole system, so it's worth slowing down on. Every template declares, up front, the exact fields it needs to make sense — a domain, a description, a before-score, an after-score, a principle. Before the engine writes a single post, it checks that every declared field is actually present in the source item. If even one is missing, the post is held.

What “held” actually means

Held is not deleted and it is not silently dropped. A held post is surfaced and flagged so a human can see it — but it is never published. The engine would rather say nothing than say something it can't stand behind. Crucially, it never reaches into the gap and fills a missing number or name with a plausible-sounding guess. A blank stays blank; the post waits.

A worked example

Suppose a milestone item arrives for a site whose score clearly rose, but the snapshot diff produced only the new score — the prior week's number is missing (say last week's snapshot was incomplete). The milestone template declares it needs both the before and the after value to write “climbed from X to Y.” With the before-score missing:

A guessing system would have happily written “climbed from 79 to 84.” This one writes nothing until the number is real. That restraint is the feature.

Deterministic templates

A template here is a fixed sentence pattern with labeled slots — something like “New in the network: {domain} — {desc}. Take a look → {url}”. The engine fills the slots with verified fields and that's the post. There is no model deciding phrasing at post time; the phrasing was decided once, by a person, when the template was written.

Why it costs nothing to run

Because filling a template is just string substitution, generating a post consumes no AI tokens and calls no paid API. The consequence is dramatic: writing 1,000 posts costs exactly what writing one costs — effectively nothing. The system's whole monthly cost is the hub server, not the content. This is why the economics don't climb with scale, and why it can run for many tenants without the bill following.

Predictability — and the honest tradeoff

Deterministic templates buy you predictability. You can read a template and know precisely what every post it produces will look like. Nothing goes out that a human didn't pre-approve at the pattern level. There are no surprises, no drift, no 2 a.m. hallucination.

The tradeoff, stated plainly, is range. A generative model can write with more surprise and variety than a fixed pattern. This system trades some of that flair for total control and zero cost — a deal that's clearly worth it when the alternative is unverifiable claims going out unattended under a client's name. It chooses trust over flourish.

How variety is achieved anyway

Fixed patterns don't have to mean repetitive feeds. Each family carries multiple template variants — several different phrasings of the same idea — so the same kind of fact reads differently from one post to the next. Combine that with hundreds of distinct sites and dozens of principles as raw material, and the output stays fresh without ever wandering off the facts. The variety lives in the selection, not in improvised wording.

The feed builder pipeline

Templates are only half the story. They're empty until something hands them clean, verified facts — and that's the feed builder's job. It runs on the MAIN server (143.198.182.180), where the whole website network and all its source data live, as the script /root/gen-social-feed.py on a nightly cron at 05:00 UTC.

Turning three raw sources into clean items

The builder reads each source and reshapes it into the tidy, typed items the templates expect:

• Site list cleaning. It reads the 177-site file, trims and normalizes each domain and description, and emits one site_feature item per usable site — skipping anything malformed so no half-built entry reaches a template.
• Pulling a real principle from each skill. For the 47-skill library it doesn't paraphrase; it lifts each skill's own stated goal where possible, and falls back to a genuine principle heading otherwise, producing ai_tip items whose words came from the library.
• Computing score gains week-over-week. It loads this week's and last week's score snapshots, diffs them, and derives milestone items (gain ≥ 5 and score ≥ 60) and new_site items (entries present now but absent last week). The math is done here, once, so the templates only ever see finished numbers.

Where it runs, and how it ships to the hub

The builder lives on MAIN because that's where the source data is — and MAIN is memory-constrained, which is exactly why the publishing brain sits on a separate hub. Once the feed is built, the script copies it to the hub at /opt/portal/listings/wholetech.json. From there, the hub's own drafting step (generate.py, cron 05:10 UTC) picks it up and turns items into queued posts.

Rotation & variety

With 177 sites and dozens of principles, the engine has far more to say than it should say at once. Two simple rules keep the feed varied and fair.

Least-recently-used first

When choosing what to post next, the engine reaches for whatever it has gone longest without using. This least-recently-used ordering means the system works its way through the entire network before it circles back to repeat anything — every site gets its turn in the spotlight before any site gets a second one.

A per-family cap

On top of that, each family has a cap so the feed doesn't tip into a monotone. Without it, the huge site_feature pool could crowd out the tips and the milestones. The cap guarantees a mix — some spotlights, some teaching, some proof — in any given stretch.

Length & formatting rules

Posts are built for the platforms they land on, so the rules are strict and simple.

• Length cap. Every post is capped at roughly 278 characters, keeping it comfortably within the tightest mainstream limits and readable at a glance. Templates are written to fit inside that budget once their fields are filled.
• Links. Where a post points to a site, it uses the site's clean canonical URL. On X, a post that carries a link costs meaningfully more than a plain one — a fact the cost controls account for (see Connecting Social Platforms).
• One idea per post. Each family says one thing — a site, a principle, a gain, a welcome. Short and single-purpose beats crammed.

Quality controls & changing the content

Several layers keep quality high, and each maps to a place you can adjust it:

For grading accuracy specifically, one real gotcha is worth knowing: if a site looks mis-scored, it may be throttling automated requests, so the engine graded a blocked page instead of the live site. The fix is to make sure it reads the live site — see Troubleshooting & Recovery.

Why this beats volume and “AI slop”

The market is full of tools that will generate an endless torrent of posts from a prompt. They optimize for volume, and volume is cheap to fake. The problem shows up the moment one of those posts states something that isn't true — a fabricated statistic, a milestone that never happened, a claim no one can back up — going out unattended under a real business's name.

This engine is built on the opposite bet: that a smaller stream of posts you can completely stand behind is worth more than a firehose you have to police. Four things set it apart:

• Real data, not invention. Every post traces to a source row — a site description, a library principle, a computed score gain.
• The honesty guard. A fact that isn't in the data cannot appear in a post. Missing fields hold the post; they never get guessed.
• Flat economics. Template writing is free, so cost doesn't climb with scale or with the number of clients — the whole system runs at the price of one small server.
• It closes the loop. With an optional human approval step and the ability to publish and then measure, this doesn't just draft — it runs the marketing.

Ready to see how it all fits together? Start with How It Works, then walk the hands-on steps in the Playbooks.