About

Who I am, and how I work

I started writing code in February 2026. Before that I’d never written a line.

I didn’t come up through a computer science degree, a bootcamp, or a tech job. I came up on the tools — mining, fishing, hospitality, retail, farming. Years on the frontline. I’ve seen how real businesses actually run, how a crew actually works, how a foreman keeps a job moving, and how things break when nobody’s paying attention.

Three months after my first line of code, here’s where I am: a working hardware-health tool I use on my own machine every single day, a multi-agent AI safety system, a desktop control-plane app, an audit on someone else’s codebase, and a stack of earlier projects behind it — some finished, some half-built, all dated. I’ll show you the dates. Nothing here is dressed up.

Here’s the part that actually matters, and it’s the thing I’m selling.

I run AI agents the way I used to run crews. I treat them like employees. They’re accelerators, not replacements. I’m still the one steering, still the one catching their mistakes, still the one signing off before anything ships. The agents themselves are off the shelf — Anthropic’s. What’s mine is the way I run them: I give each one a name, a narrow job, a written role prompt, and a checkpoint it can’t skip, and I keep myself in the loop as the final call. I’ve done that across six different projects. It’s not a slogan — it’s prompt files and workflow rules sitting in folders on my machine. I’ll show you those too.

A client hiring me isn’t hiring a junior coder catching up to other juniors. They’re hiring an operator who knows how to direct AI work and has three months of receipts.

Yes, I used AI to make this. That’s the point.

Someone’s going to ask whether I really made this myself, or whether the AI did it. It’s the wrong question, so I’ll put the answer up front.

I used AI to build this page. I use AI on everything I can. And I read every word, checked every claim, and signed off on all of it — the same way I do with code, the same way a foreman signs off on a crew’s work before it leaves the site. That’s not hiding behind a tool. That’s the job. The skill was never typing every character myself. The skill is directing the work, catching what’s wrong before it ships, and standing behind what goes out the door.

I call it agentic living: use the best tools wherever they help, and stay the one in charge. If you want someone who refuses to touch AI so he can call himself pure, that’s not me. If you want someone who uses it hard and still owns every line — that’s exactly me. This page is the proof of it. I made it the way I’d make yours.

The rules I run the crew under

These aren’t theory. They came from real jobs where something went wrong and I wrote down the lesson so it wouldn’t happen twice.

• Working version first, polish second. Ship the plain, mechanical, operator-checked version first. Make it nice after it works.
• One thing at a time. On staged work, I stop between batches and wait for the go-ahead. I don’t let an agent run straight through, even on a clean job.
• Test the fix against real data before I write it. For any non-trivial bug, I replay it against what’s actually on disk, check the data flow, and stress the design — before a line of the fix gets written.
• Five failed fixes means the problem isn’t the code. If the same fix keeps not working, the thing I think is broken isn’t the thing that’s broken. I step back instead of swinging again.
• Hostile-input test before “done.” Anywhere a user or a file can put text into the system, I throw bad input at it on purpose before I call it shipped.
• Say up front whether a file is safe to delete. Every scratch file gets that call made out loud, so nothing important goes in the bin by accident.
• Write it down so the next person can pick it up cold. Human or agent. Handover docs, current-state files, decision logs, audit trails. The next person on the job shouldn’t have to ring me to start.

If you’ve worked a site, you’ll recognise the shape of all of that. Method statements, sign-offs, RFIs when you’re blocked, a checkpoint you can’t skip. I run software the same way.

How I work with AI — the crew

This is the spine of everything above. I don’t treat an AI like a magic 8-ball you shake and trust. I run them like a crew: I give each one a name, a narrow job, a written role prompt, and a checkpoint it can’t skip — and I stay in the loop as the foreman who signs off. Let me be straight about what that is and isn’t. The agents are Anthropic’s, off the shelf. What’s mine is the method around them — the role separation, the workflow rules, the prompt files, the checkpoints. That’s light scaffolding, not a deep technical build. The one real exception is WARD, inside L.I.LY: that’s a genuine multi-agent safety system in code — a four-tier ladder with a hash-locked rulebook — built under my direction and checkpoints, not light scaffolding. Here’s the bird’s-eye view.

Same shape every time: agents I name and scope narrowly, the operator holding final authority, and the rules written down. The agents are accelerators. The judgment is mine. When one gets it wrong — and they do — I’m the one who catches it before it ships, because the checkpoints that catch it are mine.

I’m not locked to one vendor, either. I mostly run Claude models day to day, but I’ve worked across Claude Code, Cursor, Cline, and Windsurf. I pick the tool for the job. The work is AI-assisted; the calls are mine.