Most posts about letting AI build your marketing show you the finished site. Then they ask you to take the rest on faith.
We would rather show you the log.
On the night of 3 July 2026, we set an AI agent loose on a marketing build. The site is a UK property platform we run ourselves. Nobody watched it work. Every commit had to pass the product's own type checks, test suite, and production build.
Here is what that night looked like. And what was still standing by morning.
The anchor, written before anything else
Nothing shipped that night without being written down first.
Before the run started, we wrote a short brief. We call it a vision anchor. It said what the marketing surface had to become. Which competitor to study. Which kind of tools were worth building. What a blog post on this platform should sound like. What counted as done.
The agent did not get to invent the goal as it went. Every commit had to trace back to a line in that document. If it did not trace back, it did not ship.
That matters more than it sounds. Unattended AI work drifts. Left to its own judgement over a long session, a coding agent wanders. It starts on a keyword tool. Then it redesigns the navigation. Then it adds a feature nobody asked for. Each step looks reasonable on its own. The sum is a mess.
A written anchor is what stops that. It is not a prompt. It is a contract the agent keeps checking itself against.
The gate on every commit
The second piece is duller and does more work. Nothing landed without passing the product's own checks.
Type checking. The full test suite. A production build. Not a lint pass. Not a quick look in the browser. The same gate a person has to clear before merging.
A commit that failed any one of those three did not exist. It got fixed, or it got dropped.
That sounds obvious until you see what it rules out. It rules out shipping a broken page because it looked fine on screen. It rules out a calculator with a quiet maths error, because a test catches that before the commit lands.
It rules out the thing people actually fear about AI working alone. Not that it turns malicious. That it quietly does something wrong, and nobody notices until a customer does.
What the night actually built
The run worked through a list of concrete jobs, not one big task.
First it read the category leader's site by hand, page by page. It produced a teardown with a verdict on every feature it found: adopt, adapt, or skip. No invented statistics about the competitor. Only what you can see on the page.
It built a keyword opportunity matrix the same way, from live search results. Each term mapped to a specific page worth building, not a generic list of terms.
Then it built.
Free calculator tools came first. Each one reuses the platform's own tested calculation engines instead of rewriting the maths. Each one ships with the markup search engines need to read it properly.
Then a blog platform on top of MDX. The sitemap, the robots file, and llms.txt all generate from one route registry. Not hand-kept in three places that drift apart.
One detail we are fond of. The run wrote a test that bans the em dash from ever appearing on a marketing page again. The em dash is an AI writing tell. So the tool that spent all night writing copy left behind the thing that checks its own writing.
Git history shows 101 commits landed between the evening the run started and the next one. Not 101 attempts. 101 that cleared the gate and stayed.
What was true by morning, and what we checked afterwards
Most of these stories stop the morning after, with a screenshot and a claim.
We keep going. The honest question is not whether it looked done. It is whether it held up when we re-ran everything ourselves.
So we did, and we still do. Re-running the platform's suite today shows 1,400 tests passing. A clean production build produces 186 static pages. Neither number is quoted from a log. We ran the commands ourselves before this post went out.
The night was the start of a build that kept compounding. It was not a one-off stunt. That same codebase has taken 706 commits across 27 active days since work began. Today it carries 16 free tools and 68 articles.
We did not pick the best morning and stop measuring. The commit history and the file counts are still there to re-check. The full breakdown sits on the case study page, including which commits a person wrote and which the agent wrote.
We are also honest about what a night like this does not do.
It does not replace a person deciding what the business should say about itself. That decision happened in the vision anchor, before a single commit landed.
It does not catch every judgement call a person would make differently. Some of what shipped that night got revised in daylight, once a person looked at it fresh.
And it does not work without the gate. Take out the type check, the test suite, or the build step, and you no longer have an overnight marketing engine. You have an unattended process writing straight to production. That is a different and much riskier thing.
Why we are showing you the log instead of the result
We publish the commit log rather than the finished pages because the log is the actual product.
Anyone can point an AI model at a website brief and get something plausible by sunrise. The hard part is the scaffolding around it.
An anchor specific enough to hold the work to a target. A gate strict enough that nothing skips the checks a careful engineer would run anyway.
That scaffolding is what we install when we run a marketing function for a client. Not a one-off demo night.
Want the full breakdown, including where the numbers came from and how we re-derive them? It lives on our case studies page.
Want to know what a night like this would look like against your own marketing? Start with the free 15-minute call. Not a sales pitch. A straight look at what we would build first, and why.