Interactive demoMeta and TikTokSynthetic data for a fictional brand
Every ad checked against the plan, with evidence, before it spends.
Buildcheck expands the media plan into the full build, then checks the platform's own export against it and flags what doesn't match: a wrong budget, a wrong link, a missing headline. Each finding shows the plan value, the export value and the rule that decided it. It ran in production on Meta, where a media team used it on live batches, and it turned a four-day, four-person review into one 20-minute run.
A working version of the engine's logic, running in your browser on a synthetic account.
Where the AI fits. In production, step 4 runs as a Claude skill. It works from a written rulebook, cites the plan value, the export value and the rule for every finding, and sends anything it can't prove to a person. This demo runs the same rules as code in your browser, on a fictional coffee brand, so every run is instant and repeatable.
Eight problems are planted in the inputs: seven in the Ads Manager export and one in a plan cell. One of them is repeated across every ad in an ad set. Fixes change the inputs (the export or the plan cell, whichever was wrong), just as they would in a real loop. The demo runs a subset of the production rulebook. When you're done, read how I keep the AI honest. That's the part worth asking me about.
The plan feeds from the workbook: every campaign, ad set and ad as it should be built.
A synthetic bulk export: every campaign, ad set and ad as it was built.
One row per run, the way the workbook's run register logs it.
| run_id | run_date | mode | platform | scope | planned | pass | fail | missing | needs_review | n_a | extra | ready | top_failing_check | proposals |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| No runs yet. | ||||||||||||||
Five steps, from the media plan to the QA report. Each has fixed inputs and a fixed output, so a batch can be run again until it's clean.
A paid social build is a tree of settings: a few campaigns, a dozen ad sets, dozens of ads, each with 30 to 100 fields. Before Buildcheck, the plan was typed by hand and a senior person re-checked every row against Ads Manager. Errors that slipped through spent money.
A build is a tree. Each level has its own settings and its own export columns, so the engine runs a different set of checks at each level. At the ad level the checks also depend on the ad type: an uploaded video, a boosted post from the brand's own page, or a creator's partnership post.
Campaign objective · budget · flight
└ Ad set audience · placements · goal
└ Ad creative · copy · link · CTA · tracking
Where the demo's plan feeds come from.
A synthetic account, filled in the way a real one is: two campaigns, six ad sets, fifty ads. Row 2 is the human header. Row 3 is the machine name, the contract every formula, feed and finding refers to, so columns can move without anything breaking. Switch to TikTok to see the same design on another platform. The grids scroll both ways.
The prompt was the easy part. The hard part was deciding what the model may call a failure, what it has to show for it, and what a person still signs off on.
I didn't ask an AI to “check the campaign”. I wrote the rulebook first: what counts as proven, what a blank means, what it must never invent, which ad type gets which checks. The AI gets those rules as versioned reference files, not chat instructions.
Each finding has to cite the plan value, the export value and the rule that decided it, down to the plan row and the export cell, or it doesn't go in the report. Anything the engine can't verify is filed as a review rather than a failure, and anything new it comes across goes in as a proposal for a person to accept.
Claude wrote the build and test scripts to my spec. I owned the architecture, the rules, the test plan, the rollout and every changelog row. When a run got something wrong, the fix went into the rules and the test fixtures, not into memory.
The skill was shared across the organization and used by a media team on live batches. That feedback loop produced eleven releases in twelve days. A manager's “this doesn't read as auto-fill” became the gray-cell design two versions later.
An AI that reads a 100-column export and writes a confident report is dangerous unless it's boxed in. Each of these was written after a real run got something wrong.
The same work, before and with Buildcheck.
On live batches, it caught French copy mismatches, unintended Advantage+ settings and missing Stories headlines before launch. That's the kind of error a reviewer sees on ad 1,900 and misses on ad 1,901.
| Step | Before | With Buildcheck |
|---|---|---|
| Filling the plan | Days of rows typed by hand from the media plan and brief | Minutes. The grid expands into the build, with derived values filled in. |
| Batch QA | Four people, four days for a 2,000-ad batch | One 20-minute run, with every finding cited |
| Review before build | Every row checked by hand | A nine-check gate per line. Senior reviewers read the grid and the exceptions. |
| QA after build | Field-by-field comparison by eye, across an export of 100+ columns | Rules run in code, and every finding cites the plan value, export value and rule |
| Trust | Depends on who checked | A proof register: the list of mappings a person has verified against a real export. A FAIL can only rest on one of those. |
| Audit trail | Chat messages and memory | A register row per run, a changelog row per rule change, and findings pasted back into the workbook |
One media plan holds every platform's lines, and each line is checked in the workbook for its platform. The tabs, feeds and engine stay the same. Each platform brings its own export contract, vocabulary and naming profile.
In production on Facebook and Instagram
Built on the same architecture
yyyy/m/d HH:mm, amounts with cents, pixel labels resolved to website-event codes.Three more platforms, on paper
Every release is generated by script, recalculated to zero errors, regression-tested and logged.
Google Sheets first, with Excel and LibreOffice compatibility checked on every release: 310,000+ formulas recalculated headless to 0 errors. Built for 1,000 ads, 500 ad sets and 300 campaigns per account.
Python build scripts regenerate every version from a registry, so nothing is edited by hand twice. A fixture suite of executable rule cases, plus structural checks for row alignment, stale references and changelog conformance, runs before a release ships.
A Google Apps Script menu expands a media-grid line into the build, fills derived values in gray and applies the account profile. Running it again is safe: a second click adds nothing.
A changelog with the before, after, reason, downstream impact, regression test and the run that validated each change: 180+ entries, and a conformance check that must read YES. Rule changes ship as versioned files, never as edits in chat.
A Claude skill: a skill page, reference files for the run rules, the report spec and known failure modes, an HTML report template and a standing run message. It was first deployed as a shared, org-wide skill and now runs with the workbook uploaded directly.
Every mapping was proven against live Ads Manager exports up to 500+ columns wide. The largest end-to-end test reconciled a plan against a 974-row live account export.
I designed, specified and shipped Buildcheck end to end while working in media operations at a paid social agency.
It started as a fix for a real problem, a senior team spending days on checks that were mostly mechanical. The fix grew into a workbook that describes itself, an engine that has to show its evidence, and a record of every decision.
Where it fits is in-house social media marketing and strategy. A brand's social team owns organic and paid together, and the paid side is only as good as its operations: how campaigns get planned, built, checked and launched. This project is that discipline, plus the AI and systems fluency to make a small team run like a large one.
Internally, the workbook is known as the Gem Arch Doc, after the agency's term for a campaign architecture document.
The demo and the workbook run on synthetic data. Halcyon Coffee Roasters, Maya Brews, and every ID and number in them are invented to show the mechanics. No client data was used.