AI-native builder · systems design + AI orchestration · open to relocate

I don't write the code. I design the system and direct AI to build it — and I shipped one to production.

Software is starting to be built by people who design systems and direct AI, not by people who hand-write syntax. I'm already there. I designed PANTHEON — multi-tenant isolation, governance, metering, agent safety — from first principles, then directed AI to build all of it: solo, to production, running real businesses' data. I can't write the syntax and I don't need to. What I bring is the systems thinking to design something most engineers couldn't ship, and the discipline to make the machine prove it works.

Isaac Teague Frayling · Cardiff, UK · UK citizen · open to relocate worldwide (sponsorship needed outside the UK & Ireland) · one-page CV →

↑ The hero art, favicon, avatar and social card on this page were all generated by the system I built. The work made its own portfolio.

don't take my word for it

You can check every claim here in 10 seconds.

No slides, no "trust me." The system is live — go break it, then have the code behind it reviewed under NDA. What I shipped is real and running, whether or not I typed a character of it.

the value

What I actually bring.

Systems thinking that holds under attack

I designed strict multi-tenant isolation on Postgres row-level security — two-role, fails closed — that an 80-agent adversarial audit couldn't cross. I didn't write the SQL. I designed the model — the failure modes, the blast radius — and drove the build until it held.

I design governed AI, not prompt-glue

The governed agent loop — perceive → knowledge → tools → judge → meter, with guardrails, a crisis protocol, overdraft-proof metering and human-approval gates — is my design. The control-plane thinking is mine — AI wrote the code to my spec.

Idea to production, by directing AI

The substrate, a no-code Studio, bespoke generative art, a live Telegram channel (WhatsApp built, pending Meta approval), metering, auth, custom domains. All of it my idea, all of it built by directing AI — Postgres to pixels, shipped and running, solo.

I make the machine prove its work

I hold AI-built code to a bar most hand-written code never meets: a purity boundary enforced in CI, 819 tests, an 80-agent audit where every finding was refuted before it counted. Directing AI well means refusing to trust it — that's the actual skill.

Judgment, not just output

I ship the honest version: every number on the audit page carries its own asterisk, the site says out loud what isn't solved yet, and safety — a crisis message reaches help even at zero credits — beats the metric. I'd rather be trusted than impressive.

I move fast without breaking the guarantees

Every new capability keeps the same invariants: a golden-file harness proves changes are byte-safe, an edit ledger makes every change undoable, and anything that adds new surface gets an adversarial security pass before deploy. I move fast without letting the machine cut corners.

the method

How I build — the honest version.

I'm not an engineer and I won't pretend to be. I can't write the syntax or whiteboard an algorithm. I design the system and direct AI to build it — and PANTHEON is what that produces. Here's the shape of it:

What I do

Design the system from first principles → break it into pieces AI can build → direct AI to build each one → attack the result until it holds → ship it and keep it running in production. That's the loop, end to end.

Concepts I know cold

Multi-tenant isolation & trust boundaries · governance tiers & human-in-the-loop · atomic metering & rate control · agent loops, tools & guardrails · prompt-injection defence · failure-mode & blast-radius thinking. I designed all of these — I just talk about them in plain English, not jargon.

Systems I've shipped (and understand end-to-end)

Postgres with row-level security · FastAPI services · a governed agent loop · MCP, both directions · React frontends · Docker / nginx deploys. I directed the build and I know how every piece behaves — I don't hand-write it.

How I keep AI honest

CI purity boundaries · golden-file snapshot tests · 819 tests green · 80-agent adversarial audits where every finding is refuted before it counts. The instinct to distrust the machine's first answer is the whole job.

the receipts

The evidence, with the asterisk already attached.

I'd rather you trust the parts that are real than be impressed by parts that aren't.

1mind, no team* designed + directed solo
819tests green* not a formal proof
80 → 0adversarial agents, zero criticals* self-run, not third-party
livein production, real tenants* single instance — I haven't had to scale it yet
2 → 1businesses, one spine* platform, not a demo — proven by lint

the honest deal

What you're getting — and what you're not.

The architect + director, not the typist

I own the systems thinking and the delivery through AI — deciding what to build, designing how it holds, and pushing it until it's shipped. Pair me with engineers who own the line-level craft I don't, and you get things built that neither of us ships alone.

The discipline AI doesn't have on its own

Every change that matters gets adversarial review — I never trust the machine's first answer. That instinct, not any programming language, is what makes AI-built systems safe to run. It's the rarest part of the job, and it's the part I'm best at.

What I can't do

I can't write syntax, whiteboard an algorithm, or debug at the line level. If the role needs hands-on-keyboard engineering, I'm the wrong hire — and I'll tell you that before you spend a slot on me. What I do sits upstream of that: decide what to build, and make it real.

the ask

What I'm looking for.

A team where designing systems and shipping them with AI is the value — a founding builder, a 0-to-1 product hire, or an AI-native role where output and systems judgment beat pedigree. I'm open to relocate worldwide for the right one, and I care more about the problem and the people than the title.

Not for me: a role that needs me to write code by hand or pass a coding screen — that isn't what I do, and I'd rather say so now than waste your time.

Why a job, not my own startup?

Fair question. I could raise on PANTHEON — but I know exactly what it's short on, and it isn't the build. It's distribution: the network and reach to put it in front of the businesses it's built for, which I don't have and won't fake. I'd rather bring this to a team that already has that reach than spend years becoming a founder I'm not. Building it solo proved I can design and ship the whole thing. Taking it to market alone was never the plan — PANTHEON stays live as proof, not as a side project splitting my focus.

day one

Point me at a problem — here's what I'd do first.

Not "learn the ropes for a quarter." The method that built PANTHEON, pointed at your product:

Map the trust boundary

Find the tenancy / authorization / blast-radius edges and work out how each one fails — before anything gets built. You can't govern what you haven't drawn, and drawing it is what I do.

Find where safety is bolted on

Find the safety that was added after the fact — the overdraftable meter, the ungated action, the tool that trusts its caller — and redesign it so the guarantee is built in, not bolted on.

Direct the build, then prove it

Spec it, direct AI to build it, and ship it with the check that proves it — a test, a snapshot, an invariant — so the next person can move fast without having to prove it all over again.

Let's talk.

Tell me the role and what you're building. I read every email and reply within a few days — then a call, a live walkthrough of the system, and the code reviewed under NDA.

Prefer to poke before you write? Break the assistant, attack the isolation, or message the bot — it's all live.

No LinkedIn, no public repos — the live system is the portfolio; the code is under NDA. View / download my CV →