Skip to main content
Mercury Local
Dispatches

What AI actually did

We Built Our Own, No. 15. What I decided, what the machine built, what it got wrong.

PC
Peter Cellino· Publisher, The Charlotte Mercury
||4 min read
Series card No. 15: What AI actually did. Over a screenshot of the platform (cltmercury com feed xml).

Every piece in this series has said "we built" and meant one publisher and an AI. This is the piece that says what each of us did, without the two available exaggerations: that the machine did it all, or that it was just a faster typist.

What I did

I decided what the company is, in data. That a publication is a row and the domain decides which one you are looking at. That every article, page, person, transcript, document and image lives in one database with one set of permissions. That a person has one page forever. That a story is not published until its ledger exists. That analytics gets its own machine. That a rule worth having goes in the database, not a document.

I decided what to keep and what to leave. Every one of Farmington's five hundred and twenty-four articles came along. The media server did not. The analytics vendor did not. Point-in-time database recovery did not, on price, and I own that call.

I decided what the newsroom desk is shaped like, which is shaped like reporting: transcripts, documents and people at the centre.

And I did the thing no machine can do for a publisher: I read the pages. Every failure in this series was found by a person looking at the thing itself. The image ratio, the wrong category, the profile with private details on it, the calendar that said overdue, the site that was slow. The machine built the fix, and then built the check so a person would not have to look next time.

What the machine did

It wrote the code. All of it: the site, the desk, the migrations, the email path, the rendering, the caching, the checks. It ran the migrations, moved 7,124 images, rewrote 1,006 image addresses in one statement, and verified them. It wrote the tests and ran them. When the rules moved into the database, it wrote them, and then tested each one against the real failure re-created in a transaction that was undone afterward, before the rule went live.

It does the daily work that would otherwise not get done: the 64 nightly checks, the fact ledger (the record of sourced claims) on every story, the cold read of every draft by a reader who has seen none of the sources, the capture of an arrest log every weekday from a town website that keeps it for a week, the off-site mirror at 10:20 every night.

And it got things wrong, which I would rather say than have someone discover. It fabricated details in a draft, once, in May, and the review caught it; that is why the ledger exists. It cached the wrong thing first and moved nothing. It hand-tallied a season record from a schedule feed and got it wrong by one loss; that is why records now come only from a standings source. It kept a backup list current in a comment and not in the code. In each case the correction came from a person noticing, and the durable fix came from the machine building a rule that fires without one.

What we have not measured

There is no hours-saved number in this series and there will not be one. We have not run the comparison, and a figure I have not measured is a figure I do not publish. What I can say is narrower and I think more useful: the platform described here was built between March and September 2026 by a company of one, and I do not believe it would have been built by that company without the machine. Not more slowly. Not at all.

The distinction

Here is the line I would draw. The machine is not the architect, and pretending otherwise produces systems shaped like nobody's intentions. The machine is also not a tool in the sense a word processor is, because it makes ten thousand small decisions a day that no one reviews individually, and the only defence against that is to decide the rules in advance and put them where they fire.

That is the honest version. A person decides what the thing is and reads the result. The machine builds it, runs it, checks it, and is wrong often enough that the checks are not optional. We built our own because that arrangement is only possible when the whole stack is yours to decide about.

This is No. 15 in We Built Our Own. Previous: Sixteen publications, one codebase. Last: Why we did not rent it.

Topics: AI & Agentic · Platform Thesis

PC
Peter Cellino

Publisher, The Charlotte Mercury

Peter Cellino is the publisher of The Charlotte Mercury and founder of Mercury Local, the platform that runs it. He writes on agentic AI, platform economics, and the future of independent local journalism.

More on Mercury Local

More in Dispatches