One man. A fleet of AI agents.
Everything shipped with receipts.
Since February 2026 I’ve been running a one-man software factory (it trades as BygMedAI): me, directing a fleet of AI agents through multi-agent orchestration, adversarial review and enforced quality gates. Not a demo, not a deck — a production system with 15 client-facing solutions to its name — live webshops and platforms in production, and new products in active build. This page is why you can trust me to navigate your AI initiative: I’m not repeating what I’ve read. I’m reporting from the water. Or skip straight to one real change’s journey through the whole pipeline →
One operator, since February.
February: 44 commits. May: 1,529. From zero to a running factory in one quarter. Counts measured every morning from the GitHub API — every measurement is public, method reproducible; commits and pull requests are counted on default branches only, so both are lower bounds. The source code is private by design — client work stays confidential. The proof lives where it should: in production, with real customers, and in a contribution graph you can inspect right now.
Two pictures the numbers make.
From zero to a running factory in one quarter.
- 1February: the factory is founded mid-month — the first website ships within a week of touching the tools.
- 2March: the infrastructure pivot — governance and the agent fleet are built before scaling output, not after.
- 3May: peak build — and the production failures that forged the hardest gates. The curve settles after by design: quality over velocity. June and July held at 730–750; August had passed 700 by the 18th. September started slower and picked up: the factory’s commit count rose by 330 from 31 August to 16 September, then by 323 in the ten days to 26 September — measured every morning.
A third of the factory is paper trail. On purpose.
What lives in that third, in one repo alone:
A bunch of prompts leaves no paper trail. A factory is mostly paper trail — dispatches that bound the work, reviews that attacked it, evidence that proved it. That third is why the other two thirds can be trusted. Scroll through one real change’s journey to see the trail in use →
How one person ships like a team.
The short answer: not by prompting harder. By running agents the way you’d run a delivery organisation — with mandates, review and hard gates. Four mechanisms carry the whole thing:
Multi-agent orchestration
Each agent runs under a written mandate: what it owns, what it may touch, when it must stop and escalate. Ambition scales with memory and governance — never ahead of them. An agent asked to be seven people is an agent that fails as all seven.
Human-in-the-loop, always
Agents build; I direct and decide. Every merge crosses a human decision point. The judgment layer — what to build, what "good" means, when to say no — never gets delegated. That’s the part 20 years of programme delivery trained.
Adversarial review
Agents check other agents’ work — and they’re prompted to refute, not to applaud. AI’s most dangerous failure mode is confident, plausible-looking work that’s hollow inside. Independent adversarial eyes catch what a friendly re-read never will.
Enforced gates — not guidelines
Rules live in enforcement, not prose: hooks that block merge and deploy, leak-scans, smoke tests, evidence requirements on every “done”. If the system can’t determine status, the principle is unknown = blocked. A gate that only exists in a document is a pious hope.
A change travels an explicit chain of command: need → requirement and expected user outcome → bounded dispatch → implementation on a branch → mechanical checks → evidence pack → separate or adversarial review → human GO/HOLD → merge → deploy verification. A dispatch isn’t a prompt — it’s a machine-readable work contract: which requirement, which files may be touched, which actions are forbidden, what evidence is required, who may act and who may approve. A task missing its goal, authority, evidence bar or out-of-scope isn’t ready for an agent. It’s just ambiguity with a send button.
Prompts influence behaviour. Enforcement constrains action. That’s the difference between a helpful chatbot and a delivery model — and it’s why the most interesting page on this site is the one about failure: The Hallucination Defence — four mechanical controls and ten real failure patterns → And for the whole method as a guide your organisation can follow: The AI Playbook — seven chapters, from first boat to fleet →
The page you’re reading is the receipt.
This site was built by the factory.
Every page here was produced by an AI lead developer working under my direction — every change merged through a pull request, every one gated by an automated pipeline before a human approved the merge (the initial relaunch alone: 13 PRs in three days). Interactive playbooks, diagnostic tools, calculators, a print-perfect PDF pipeline — built in the gaps between the factory’s client deliveries. What the pipeline enforces on every single change:
- Playwright smoke tests — every page, console errors and mobile overflow
- Lighthouse budgets — accessibility and SEO scored on every run
- HTML validation and broken-link checks across the site
- Secret- and leak-scans before anything goes public
- Human review on every merge — no agent ships alone
The same factory built all three digital surfaces for Ink & Art Copenhagen, a tattoo studio established in 1996: the hub site, a custom React storefront on a Shopify commerce backbone, and a companion app — 631 commits and 491 pull requests across two repositories since May, now being matured from MVP into one connected ecosystem. The owner’s verdict on the quality: he made me a partner. And for the engineers in the room: read the full technical case on a token-authorised e-commerce & digital-delivery platform — stack, trade-offs, security model and measured numbers, method stated per figure. Or better: scroll through one real change’s journey — the actual dispatch, the adversarial review with 11 findings, the gates and the human GO.
What running this actually teaches you.
Not from a course. From running agents at production pressure, watching them fail, and building the rails that stop it happening twice.
AI is like a gas. It fills any room you give it — but it can’t hide how thinly it’s spread.
A green test is not done. A merge is not done. A plausible explanation is nothing at all.
The better the agent looks, the more governance you need. Not less — more.
Build-power is not the bottleneck anymore. Operations is.
What agents still can’t do.
Anyone selling AI without a list like this hasn’t run it under pressure. The factory works because it’s designed around these three limits:
Hold quality under pressure without rails.
Accelerate an agent past its capacity and it doesn’t refuse — it produces something that resembles the work. Speed must be earned with structure; it cannot be demanded.
Tell you it’s guessing.
An agent without access to the real data will sometimes produce excellent-sounding answers anyway. Verification can’t be a courtesy — it has to be mechanical, every time.
Own the judgment.
Taste, priorities, what “good” means, when to stop — that stays human. The factory doesn’t replace judgment; it multiplies the reach of one person’s judgment.
That third limit is why the 20 years matter. Directing a fleet of agents is a delivery-leadership problem: mandates, review, gates, escalation. I’d been rehearsing for this job my whole career — the tools just finally caught up.
Sailing into AI without a navigator?
Every organisation is heading into this water right now — most with nobody on board who has actually sailed it. That’s the role I take: the senior programme leader who has built with AI hands-on, and steers your initiative from idea to working delivery. (Need something built? That’s the factory: BygMedAI.)