Creative operations · Agent-native engineering
From first commit to live client production in about six weeks, on a codebase built for AI agents to work on safely
A multi-tenant production platform that replaced two legacy tools and the email chains around them. Built and run by a very small team working with a coordinated fleet of AI coding agents, under rules the repository itself enforces.
~6 weeks
From first commit to real client work in production
≈ 9 in 10
Commits co-written with an AI coding agent, under rules the repository enforces
99.7%
Historical jobs priced identically by the new pricing engine; every difference was a real bug in the old one
~¾
Of an independent audit’s open backlog, closed in one release by a coordinated fleet of AI agents
01
The problem
A creative production studio delivers a constant stream of small, urgent jobs for brand and dealer networks: banner sets, print ads, video edits, with turnarounds measured in hours. Briefs, quotes, feedback and approvals moved through email, a ticketing tool and two third-party production platforms. Every job was scoped, quoted and chased by hand.
Feedback arrived as screenshots and long threads, so nobody could tell a billable client change from an internal mistake. One client’s orders already lived in its own ad system, and retyping them was not an option. And with the production team on the other side of the world from its clients, every deadline had to be computed in the client’s time zone, daylight saving included.
02
Why it was hard
- Multi-tenant and multi-role from day one: four role-specific workspaces plus guest reviewers arriving through secure links, each seeing only what belongs to them.
- Review on every format: pinned comments that stay anchored on images, multi-page PDFs, animated HTML5 banners and video timestamps, through re-uploads and zoom.
- A hostile integration: an external system that drops orders and packages on a file server, sometimes half-written, sometimes with corrupt dates.
- Money correctness: prices depend on product, turnaround, complexity, unit counts and video length, and history must never move once a job is delivered.
- Several producers racing to claim the same job in the same second, on serverless infrastructure.
- A very small engineering team, with up to a dozen AI agent sessions working on the same codebase at once.
03
What we built
A multi-tenant production platform. Clients brief from their own catalog, rules calculate the price, producers claim work from a shared queue, review happens on the asset itself, and every approval becomes a billing line that can never be rewritten.
04
Where the innovation is
01
A codebase written for agents as much as for people
Every agent that opens the repository reads the same hard rules first, and each rule exists because breaking it once broke production. Dozens of versioned skills travel with the code, and a paste-in prompt makes any new agent study the documentation before it touches anything.
02
A fleet of agents, coordinated like a team
Agents work in isolated copies of the repository so they never collide. After an external audit, an orchestrating agent split the open backlog across more than a dozen agents, with orders to escalate only for architecture changes, downtime risk or visible UI changes. The resulting pull requests shipped together, and every closed ticket was re-verified against the main branch with evidence attached.
03
Evidence before assertions
An agent once proposed a fix for code that nothing ever called. That became a written rule with a clear order of authority: code on the executed path first, then live data, then real artifacts, and only then documentation. Agents test in a real browser and run read-only production queries before they state a fact.
04
Prove a migration before trusting it
The new rule-based pricing engine was run side by side with the old one on every historical job. More than 99.6% matched exactly, and each of the few differences turned out to be a real billing bug in the old engine, like longer videos billed at the short-video rate.
05
Integration as an intake channel
Orders from the client’s ad system become ordinary jobs, and status, proofs and final packages flow back automatically. A guard waits for files to settle before reading them and retries before quarantining anything, so half-uploaded packages no longer become false alarms. A new client integration is a new adapter, not a change to the core.
06
History that cannot be rewritten
Who caused each revision, client or studio, is recorded at the moment of the decision, and every delivered job freezes its product, rate and turnaround into its billing line. Packages are validated against per-product rules before any reviewer sees them, including limits that block malicious archives.
05
What the numbers showed
Two measurements made the case for the way this platform was built: a pricing migration proven against history instead of assumed, and a commit history where AI agents did most of the writing under human-set rules.
Who wrote the commits
Share of non-merge commits. Agents write; the rules, reviews and production decisions stay human.
New pricing engine vs. the old one, on every historical job
Share of jobs priced identically. All three differences across both clients were real bugs in the old engine.
06
Results
- Live with real client work about six weeks after the first commit, replacing two third-party production tools and an interim ticketing workflow.
- Hundreds of deliverables a month across two client networks, with a median of one revision round per job.
- About nine in ten of one client’s orders now arrive automatically from its own ad system, with no retyping.
- Seven to eight times more throughput after a load test exposed three blockers that manual QA would have missed, and not a single double claim under contention.
- An independent QA and security audit, with about three quarters of its open backlog closed in one release, followed by two-factor authentication, verified database encryption in transit, nightly backups with restore checks and hundreds of automated tests.
- Daily throughput grew by more than a third by the third month live.
Open items from the independent audit
Index, open items before the agent fleet = 100.
07
What we learned along the way
The load test found what QA would not
Before launch, a purpose-built load test showed that a one-line database pool setting was making every request wait in line, and that reference numbers collided under concurrent submissions. Both were fixed before a single client logged in.
An agent was wrong, and the mistake became a skill
A confident proposal to re-architect a download path turned out to target code that never ran. Instead of just discarding it, the lesson became a versioned skill that every agent now follows before diagnosing anything.
Documentation is a lead, not an authority
Three months in, the architecture docs still described the original plan. They were rebuilt from the code and the live database, and every document now opens with the same rule: verify before you trust what it says.
Stack
- Next.js
- React
- TypeScript
- Tailwind CSS
- PostgreSQL
- Drizzle ORM
- Auth with 2FA
- S3-compatible storage
- Web Push
- Slack API
- Canvas annotation
- PDF rendering in WebAssembly
- SFTP integration
- Vitest
- GitHub Actions
- Vercel
- Claude Code (orchestrator + subagents)
- MCP servers
- Git worktrees
Is your operation still running on email and spreadsheets?
We build the platform your team actually needs, with the engineering discipline that lets AI agents help build it safely and keep it running.
Book a discovery sessionPlatform name, clients, people, prices and volumes are withheld or rounded under confidentiality agreements. No product screens are shown. Delivered as the specialist technology partner of a production and development agency, which held the direct client relationship.