Contents
Building with AI
Everything on this site was built with AI in the loop. That's not the interesting part anymore. The interesting part is that I direct it to do real work and I keep it honest, because a model left unchecked will invent a number, a citation, or a qualification without blinking. This is how I build so that never reaches the output.
I direct AI, and I'm the one accountable for the output
The fear every hiring manager has about an AI-fluent candidate is simple. Do they actually understand what they're shipping, or are they pasting model output they can't evaluate? It's a fair fear. Plenty of people can get a model to emit code or copy. Far fewer can look at what it produced and say "that number can't be trusted, and here's exactly why."
That second skill is the one I've built everything around. I use AI the way you'd use a fast, talented assistant who occasionally lies with a straight face. You give it the work it's good at, you never let it make the calls that have to be right, and you check what it hands back before it goes anywhere. My psychology background turns out to matter here. The useful question isn't "what can the model do," it's "where does its judgment fail, and how do I build around that." Every project below is an answer to that question.
The line I draw in every system
The same split runs through all of it. The model does the judgment-light work: reading, structuring, drafting, turning messy input into clean facts. Deterministic code owns every decision that has to be reproducible, and a verification step stands between the model's output and anything a person sees. Same inputs, same result, every time, with the AI nowhere near the part that has to be trusted.
It sounds strict, and it is. But it's the only way I've found to put a language model inside something real and still stand behind what comes out. Three projects show the pattern doing three different jobs.
An AI that tailors a resume without lying on it
Role Reaper tailors job applications, which is exactly the task where an unsupervised model will inflate experience and invent skills to make the fit look better. So it physically can't. The resume bullets are stored verbatim and the model is only allowed to reorder them by relevance to a role. It never rewords a bullet, never embellishes, never writes a new accomplishment. The model reads the posting and identifies which real skills match. The code does the ranking. Nothing untrue can get added, because adding isn't an operation the system permits.
An AI that writes, and a system that checks its work
Zenith generates research-backed workout guides, where a single invented citation would sink the brand. The model writes the prose, but it never gets to be the authority on whether a claim is true. After a draft is written, every citation runs through two independent checks. One is deterministic: does the cited paper actually exist in the research that was really pulled? The other grades the claim against the abstract. A model can write a beautiful sentence and a real-looking link to a study that was never fetched. The verification catches it, and the publish step refuses to ship anything that fails. The AI drafts. The system decides what's allowed out.
An AI that explains a score it isn't allowed to change
The Command Center scores how well a business measures its marketing, then writes the findings up in plain English. The scoring is fully deterministic, decided in code before the model is ever called. The AI's only job is to explain those locked numbers in language a non-technical owner understands. It's told, in no uncertain terms, that it may never write a score different from the one it was handed. The judgment is the code's. The translation is the model's. They never trade places, so the number you read is always the number the system actually computed.
How I actually build with it
Day to day, I use AI to move fast across a stack that's wider than any one person could hold in their head at once. Node services, Apps Script pipelines, headless automation, API integrations, frontend, SQL. I direct the model to draft and structure, and I review everything it produces the way I'd review a junior engineer's pull request, because that's what it is. When it reaches for something plausible instead of something true, I catch it and send it back. When it hands me a wall of code, I render it and test it before I trust it.
That's the actual skill, and it's the one that's hard to fake. Not prompting. Knowing what good output looks like, spotting the moment the model starts confidently making things up, and having the judgment to stop it before it ships. The speed is real. So is the supervision. I wouldn't ship one without the other.
What it demonstrates
I build production systems with AI inside them, and I'm the human accountable for what comes out. I know where a model's judgment is useful and where it can't be trusted, and I build the second thing into the architecture instead of hoping for the best. In a market full of people who can make AI produce something, I'm one of the ones who can tell you whether what it produced is right.